#include <bits/stdc++.h>
// #pragma GCC optimize(3)
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
#define F first
#define S second
#define endl '\n'
#define bpc(x) __builtin_popcount(x)
#define bpcll(x) __builtin_popcountll(x)

using namespace std;
using ll = long long;
using i128 = __int128;
using pii = pair<int, int>;
using pll = pair<ll, ll>;

const ll Inf = 1e18;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int N = 1e5 + 5;

ll a[N];

struct CD{
    int n;
    vector<vector<int>> g;
    vector<int> par, sz;
    vector<bool> vis;
    vector<vector<ll>> pre;
    vector<int> sonid;
    vector<vector<vector<ll>>> preson;
    
    CD(){}
    CD(int n){
        init(n);
    }

    void init(int n){
        this->n = n;
        g.assign(n+1, {});
        pre.assign(n+1, {});
        preson.assign(n+1, {});
        par.assign(n+1, 0);
        sz.assign(n+1, 0);
        sonid.assign(n+1, 0);
        vis.assign(n+1, 0);
    }
    
    void addEdge(int x, int y){
        g[x].push_back(y);
        g[y].push_back(x);
    }
    
    void dfs(int i, int f){
        sz[i] = 1;
        for(auto j : g[i]){
            if(j == f || vis[j]) continue;
            dfs(j, i);
            sz[i] += sz[j];
        }
    }

    int getCentroid(int i, int f, int n){
        for(auto j : g[i]){
            if(j == f || vis[j]) continue;
            if(sz[j] * 2 > n) return getCentroid(j, i, n);
        }
        return i;
    }
    

    void dfs2(int i, int f, int id, int root, int dep){
        if(pre[root].size() <= dep){
            pre[root].resize(dep + 1);
        }
        if(preson[root][id].size() <= dep){
            preson[root][id].resize(dep + 1);
        }

        pre[root][dep] += a[i];
        preson[root][id][dep] += a[i];
        for(auto j : g[i]){
            if(vis[j] || j == f) continue;
            dfs2(j, i, id, root, dep + 1);
        }
    }

    void work(int i, int f = 0, int id = 0){
        dfs(i, f);
        int cen = getCentroid(i, f, sz[i]);
        vis[cen] = 1;
        par[cen] = f;
        sonid[cen] = id;

        pre[cen].push_back(a[cen]);
        int k = 0;
        for(auto j : g[cen]){
            if(vis[j]) continue;
            // cerr << "(cen, j)=" << cen << " " << j << endl;
            preson[cen].resize(k+1);
            dfs2(j, cen, k, cen, 1);
            // cerr << "(cen, j)=" << cen << " " << j << endl;

            for(int x=1; x<preson[cen][k].size(); x++){
                preson[cen][k][x] += preson[cen][k][x-1];
            }
            // cerr << "(cen, j)=" << cen << " " << j << endl;

            work(j, cen, k);
            // cerr << "(cen, j)=" << cen << " " << j << endl;

            k++;
        }

        for(int x=1; x<pre[cen].size(); x++){
            pre[cen][x] += pre[cen][x-1];
        }
    }
};

vector<vector<int>> g(N);
int d[N], fa[N][20];

void dfs(int i, int f){
    for(auto j : g[i]){
        if(j == f) continue;
        d[j] = d[i] + 1;
        fa[j][0] = i;
        for(int k=1; k<20; k++){
            fa[j][k] = fa[fa[j][k-1]][k-1];
        }
        dfs(j, i);
    }
}

int lca(int x, int y){
    if(d[x] < d[y]) swap(x, y);
    int dif = d[x] - d[y];
    for(int i=0; i<20; i++){
        if(dif & (1<<i)){
            x = fa[x][i];
        }
    }
    if(x == y) return x;
    for(int i=19; i>=0; i--){
        if(fa[x][i] == fa[y][i]) continue;
        x = fa[x][i];
        y = fa[y][i];
    }
    return fa[x][0];
}

int dis(int x, int y){
    return d[x] + d[y] - 2*d[lca(x, y)];
}


void solve(){
    int n, q; cin >> n >> q;
    for(int i=1; i<=n; i++) cin >> a[i];
    for(int i=1; i<=n; i++){
        g[i].clear();
    }
    CD t(n);
    for(int i=1; i<n; i++){
        int x, y; cin >> x >> y;
        t.addEdge(x, y);
        g[x].push_back(y);
        g[y].push_back(x);
    }

    t.work(1);

    // cout << "pre:\n";
    // for(int i=1; i<=n; i++){
    //     cout << "i=" << i << endl;
        
    //     for(int j=0; j<t.preson[i].size(); j++){
    //         cout << "son=" << j << endl;
    //         for(auto x : t.preson[i][j]){
    //             cout << x << " ";
    //         }
    //         cout << endl;
    //     }

    //     for(auto x : t.pre[i]){
    //         cout << x << " ";
    //     }
    //     cout << endl;
    // }



    // cerr << "done CD\n";
    // cout << "CD parent\n";
    // for(int i=1; i<=n; i++){
    //     cout << t.par[i] << " ";
    // }
    // cout << endl;

    d[1] = 0;
    for(int i=0; i<20; i++){
        fa[1][i] = 0;
    }
    dfs(1, 0);

    auto cal = [&](int x, int d) -> ll {
        ll res = 0;
        int now = x, son = -1, dc = d;
        while(now){
            int y = min<int>(dc, t.pre[now].size() - 1);
            if(y >= 0){
                res += t.pre[now][y];
            }
            if(son != -1){
                int id = t.sonid[son];
                int yy = min<int>(dc, t.preson[now][id].size() - 1);
                if(yy >= 0){
                    res -= t.preson[now][id][yy];
                }
            }
            son = now;
            now = t.par[now];
            if(now){
                dc = d - dis(now, x);
            }
        }

        return res;
    };

    for(int i=1; i<=q; i++){
        int x, l, r; cin >> x >> l >> r;
        // cout << "i=" << i << endl;
        // cout << "(x, r, val)=" << x << " " << r << " " << cal(x, r) << endl;
        // cout << "(x, l-1, val)=" << x << " " << l-1 << " " << cal(x, l-1) << endl;

        ll res = cal(x, r) - cal(x, l-1);
        cout << res << endl;
    }

}

int main(){
    ios::sync_with_stdio(0); cin.tie(0); 
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);

    int t = 1;
    // cin >> t;
    while(t--){
        solve();
    }

    return 0;
}