#include <bits/stdc++.h>

using LL = long long;
using ULL = unsigned long long;

constexpr int N = 200005;

int n, m;
ULL a[N];
std::vector<int> tree[2][N];
int fa[2][N][20], dep[2][N], dfn[2][N], size[2][N], dfc[2];
template <int o>
void pre_dfs(int u, int p) {
    if (o == 1) a[u] += a[p];
    size[o][u] = 1;
    dfn[o][u] = ++dfc[o];
    dep[o][u] = dep[o][p] + 1;
    fa[o][u][0] = p;
    for (int i = 1; i < 20; i++) fa[o][u][i] = fa[o][fa[o][u][i - 1]][i - 1];
    for (int v : tree[o][u]) {
        if (v == p) continue;
        pre_dfs<o>(v, u);
        size[o][u] += size[o][v];
    }
}
template <int o>
int lca(int x, int y) {
    if (dep[o][x] > dep[o][y]) std::swap(x, y);
    for (int i = 19; i >= 0; i--) if (dep[o][fa[o][y][i]] >= dep[o][x]) y = fa[o][y][i];
    if (x == y) return x;
    for (int i = 19; i >= 0; i--) if (fa[o][x][i] != fa[o][y][i]) x = fa[o][x][i], y = fa[o][y][i];
    return fa[o][x][0];
}

constexpr int B = 450;
int tot, key[N], pos[502];
int get_key(int u, int p) {
    int max = 0;
    for (int v : tree[1][u]) {
        if (v == p) continue;
        max = std::max(max, get_key(v, u) + 1);
    }
    if (u == 1 || max == B) {
        key[u] = ++tot;
        pos[tot] = u;
        max = 0;
    }
    return max;
}

std::vector<std::pair<int, ULL>> h[N], g[N], d[502];

struct Blocks {
    ULL h[502];
    ULL g[502][502];
    int bl[502], br[502], bel[N];
    void build() {
        for (int i = 1; i <= n; i++) bel[i] = (i + B - 1) / B;
        for (int i = 1; i <= n; i++) br[bel[i]] = i;
        for (int i = n; i >= 1; i--) bl[bel[i]] = i;
    }
    void add(int x, ULL v) {
        int b = bel[x];
        for (int i = b; i <= bel[n]; i++) h[i] += v;
        for (int i = x; i <= br[b]; i++) g[b][i - bl[b] + 1] += v;
    }
    ULL query(int x) {
        int b = bel[x];
        return h[b - 1] + g[b][x - bl[b] + 1];
    }
};
Blocks blocks;

ULL ans[N];

int tag[N], val[N];
void dfs(int u, int p) {
    val[u] = val[p] + tag[u];
    for (int v : tree[0][u]) {
        if (v == p) continue;
        dfs(v, u);
    }
}

int main() {
    std::cin >> n >> m;
    for (int i = 1; i <= n; i++) std::cin >> a[i];
    for (int i = 1; i < n; i++) {
        int x, y;
        std::cin >> x >> y;
        tree[0][x].push_back(y);
        tree[0][y].push_back(x);
    }
    for (int i = 1; i < n; i++) {
        int x, y;
        std::cin >> x >> y;
        tree[1][x].push_back(y);
        tree[1][y].push_back(x);
    }
    pre_dfs<0>(1, 0);
    pre_dfs<1>(1, 0);
    get_key(1, 0);
    for (int i = 1; i <= m; i++) {
        int x, y;
        ULL k;
        std::cin >> x >> y >> k;
        int p0 = lca<0>(x, y);
        h[i].push_back({x, k});
        h[i].push_back({y, k});
        h[i].push_back({p0, -k});
        if (fa[0][p0][0]) h[i].push_back({fa[0][p0][0], -k});
        int p1 = lca<1>(x, y);
        g[i].push_back({x, 1});
        g[i].push_back({y, 1});
        g[i].push_back({p1, -1});
        if (fa[1][p1][0]) g[i].push_back({fa[1][p1][0], -1});
        ans[i] = a[x] + a[y] - a[p1] - a[fa[1][p1][0]];
    }
    blocks.build();
    for (int i = 1; i <= m; i++) {
        for (auto [x, v] : h[i]) blocks.add(dfn[0][x], v);
        for (auto [x, v] : g[i]) {
            while (!key[x]) {
                ans[i] += v * (blocks.query(dfn[0][x] + size[0][x] - 1) - blocks.query(dfn[0][x] - 1));
                x = fa[1][x][0];
            }
            d[key[x]].push_back({i, v});
        }
    }
    for (int i = 1; i <= tot; i++) {
        for (int u = pos[i]; u; u = fa[1][u][0]) tag[u] = 1;
        dfs(1, 0);
        int p = 0;
        ULL cur = 0;
        for (auto [id, v] : d[i]) {
            while (p + 1 <= id) {
                p++;
                for (auto [x, v] : h[p]) cur += val[x] * v;
            }
            ans[id] += v * cur;
        }
        for (int u = pos[i]; u; u = fa[1][u][0]) tag[u] = 0;
    }
    for (int i = 1; i <= m; i++) printf("%lld\n", ans[i]);
    return 0;
}