#include <bits/stdc++.h>

namespace IO {
    #ifdef _DEBUG
    constexpr int MAX_SIZE = 1;
    #else
    constexpr int MAX_SIZE = 1 << 20;
    #endif
    class Reader {
    private:
        FILE *file;
        char buff[MAX_SIZE], *p1, *p2;
        int getchar() {
            if (p1 == p2) p2 = (p1 = buff) + fread(buff, 1, MAX_SIZE, file);
            return p1 == p2 ? EOF : *p1++;
        }
    public:
        Reader(FILE *_file) {
            file = _file;
            p1 = p2 = buff;
        }
        Reader(const char* file_dir) {
            file = std::fopen(file_dir, "r");
            p1 = p2 = buff;
        }
        void read() {}
        template<typename... Args>
        void read(int &x, Args &...other) {
            int f, ch;
            x = f = 0;
            ch = getchar();
            for (; !isdigit(ch); ch = getchar()) f ^= ch == '-';
            for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
            if (f) x = -x;
            read(other...);
        }
        template<typename... Args>
        void read(long long &x, Args &...other) {
            int f, ch;
            x = f = 0;
            ch = getchar();
            for (; !isdigit(ch); ch = getchar()) f ^= ch == '-';
            for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
            if (f) x = -x;
            read(other...);
        }
        template<typename... Args>
        void read(__int128 &x, Args &...other) {
            int f, ch;
            x = f = 0;
            ch = getchar();
            for (; !isdigit(ch); ch = getchar()) f ^= ch == '-';
            for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
            if (f) x = -x;
            read(other...);
        }
       template<typename... Args>
        void read(unsigned int &x, Args &...other) {
            int ch;
            x = 0;
            ch = getchar();
            for (; !isdigit(ch); ch = getchar()) ;
            for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
            read(other...);
        }
        template<typename... Args>
        void read(unsigned long long &x, Args &...other) {
            int ch;
            x = 0;
            ch = getchar();
            for (; !isdigit(ch); ch = getchar()) ;
            for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
            read(other...);
        }
        template<typename... Args>
        void read(unsigned __int128 &x, Args &...other) {
            int ch;
            x = 0;
            ch = getchar();
            for (; !isdigit(ch); ch = getchar()) ;
            for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
            read(other...);
        }
        template<typename... Args>
        void read(double &x, Args &...other) {
            int f, ch;
            x = f = 0;
            ch = getchar();
            for (; !isdigit(ch); ch = getchar()) f ^= ch == '-';
            for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
            if (ch == '.') {
                double e = 1;
                for (ch = getchar(); isdigit(ch); ch = getchar())
                    x += (ch ^ 48) * (e *= .1);
            }
            if (f) x = -x;
            read(other...);
        }
        template<typename... Args>
        void read(char &ch, Args &...other) {
            ch = getchar();
            while (!isgraph(ch)) ch = getchar();
            read(other...);
        }
        template<typename... Args>
        void read(std::string &s, Args &...other) {
            char ch;
            s = "";
            ch = getchar();
            for (; !isgraph(ch);) ch = getchar();
            for (; isgraph(ch); ch = getchar()) s += ch;
            read(other...);
        }
        template<typename... Args>
        void read(long double &x, Args &...other) {
            int f, ch;
            x = f = 0;
            ch = getchar();
            for (; !isdigit(ch); ch = getchar()) f ^= ch == '-';
            for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
            if (ch == '.') {
                long double e = 1;
                for (ch = getchar(); isdigit(ch); ch = getchar())
                    x += (ch ^ 48) * (e *= .1);
            }
            if (f) x = -x;
            read(other...);
        }
        void read(char* s) {
            char ch;
            ch = getchar();
            while (!isgraph(ch)) ch = getchar();
            for (; isgraph(ch); ch = getchar()) *s++ = ch;
            *s = 0;
        }
    };
}
IO::Reader reader(stdin);

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 = 700;
int tot, key[N], pos[1003];
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 (max == B) {
        key[u] = ++tot;
        pos[tot] = u;
        max = 0;
    }
    return max;
}

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

struct Blocks {
    ULL h[1003];
    ULL g[1003][1003];
    int bl[1003], br[1003], 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() {
    reader.read(n, m);
    for (int i = 1; i <= n; i++) reader.read(a[i]);
    for (int i = 1; i < n; i++) {
        int x, y;
        reader.read(x, y);
        tree[0][x].push_back(y);
        tree[0][y].push_back(x);
    }
    for (int i = 1; i < n; i++) {
        int x, y;
        reader.read(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;
        reader.read(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();
    const auto shorten = [&](std::vector<std::pair<int, ULL>> &a) {
        std::sort(a.begin(), a.end());
        std::vector<std::pair<int, int>> res;
        for (auto [x, v] : a) {
            if (res.size() && res.back().first == x) res.back().second += v;
            else res.push_back({x, v});
        }
        a.clear();
        for (auto [x, v] : res) if (v) a.push_back({x, v});
    };
    for (int i = 1; i <= m; i++) {
        shorten(h[i]);
        shorten(g[i]);
    }
    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 (x && !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];
            }
            if (x) 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("%llu\n", ans[i]);
    return 0;
}