#include <bits/stdc++.h>
#define pb emplace_back
#define fst first
#define scd second
#define mkp make_pair
#define mems(a, x) memset((a), (x), sizeof(a))

using namespace std;
typedef long long ll;
typedef double db;
typedef unsigned long long ull;
typedef long double ldb;
typedef pair<int, int> pii;

const int maxn = 200100;

int n, m;
ull a[maxn], c[maxn];

struct Tree {
	vector<int> G[maxn];
	
	inline void add_edge(int u, int v) {
		G[u].pb(v);
		G[v].pb(u);
	}
	
	int fa[maxn], sz[maxn], son[maxn], dep[maxn], top[maxn], dfn[maxn], rnk[maxn], tim;
	
	int dfs(int u, int f, int d) {
		fa[u] = f;
		sz[u] = 1;
		dep[u] = d;
		int mx = -1;
		for (int v : G[u]) {
			if (v == f) {
				continue;
			}
			sz[u] += dfs(v, u, d + 1);
			if (sz[v] > mx) {
				son[u] = v;
				mx = sz[v];
			}
		}
		return sz[u];
	}
	
	void dfs2(int u, int tp) {
		top[u] = tp;
		dfn[u] = ++tim;
		rnk[tim] = u;
		if (!son[u]) {
			return;
		}
		dfs2(son[u], tp);
		for (int v : G[u]) {
			if (!dfn[v]) {
				dfs2(v, v);
			}
		}
	}
	
	inline void build() {
		dfs(1, -1, 1);
		dfs2(1, 1);
	}
	
	inline vector<pii> get(int x, int y) {
		vector<pii> res;
		while (top[x] != top[y]) {
			if (dep[top[x]] < dep[top[y]]) {
				swap(x, y);
			}
			res.pb(dfn[top[x]], dfn[x]);
			x = fa[top[x]];
		}
		if (dep[x] > dep[y]) {
			swap(x, y);
		}
		res.pb(dfn[x], dfn[y]);
		return res;
	}
} T1, T2;

int p[maxn], q[maxn], bel[maxn], blo, L[maxn], R[maxn], d[maxn];
ull ans[maxn];
struct node {
	int x, y;
	ull k;
} b[maxn];
vector<pii> S[maxn], T[maxn];

namespace BLK {
	ull a[maxn], b[maxn];
	
	inline void update(int l, int r, ull x) {
		if (bel[l] == bel[r]) {
			for (int i = l; i <= r; ++i) {
				a[i] += x;
			}
			return;
		}
		for (int i = l; i <= R[bel[l]]; ++i) {
			a[i] += x;
		}
		for (int i = L[bel[r]]; i <= r; ++i) {
			a[i] += x;
		}
		for (int i = bel[l] + 1; i < bel[r]; ++i) {
			b[i] += x;
		}
	}
	
	inline ull query(int x) {
		return a[x] + b[bel[x]];
	}
}

void solve() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; ++i) {
		scanf("%llu", &a[i]);
	}
	for (int i = 1, u, v; i < n; ++i) {
		scanf("%d%d", &u, &v);
		T1.add_edge(u, v);
	}
	for (int i = 1, u, v; i < n; ++i) {
		scanf("%d%d", &u, &v);
		T2.add_edge(u, v);
	}
	for (int i = 1; i <= m; ++i) {
		scanf("%d%d%llu", &b[i].x, &b[i].y, &b[i].k);
	}
	T1.build();
	T2.build();
	for (int i = 1; i <= n; ++i) {
		p[i] = T1.dfn[T2.rnk[i]];
		c[T1.dfn[i]] = a[i];
	}
	for (int i = 1; i <= n; ++i) {
		a[i] = c[i];
	}
	blo = sqrt(n);
	for (int i = 1; i <= n; ++i) {
		bel[i] = (i - 1) / blo + 1;
		if (!L[bel[i]]) {
			L[bel[i]] = i;
		}
		R[bel[i]] = i;
	}
	for (int i = 1; i <= n; ++i) {
		BLK::update(i, i, a[i]);
	}
	for (int i = 1; i <= m; ++i) {
		S[i] = T1.get(b[i].x, b[i].y);
		T[i] = T2.get(b[i].x, b[i].y);
		for (pii _ : S[i]) {
			BLK::update(_.fst, _.scd, b[i].k);
		}
		for (pii _ : T[i]) {
			int l = _.fst, r = _.scd;
			if (bel[l] == bel[r] || 1) {
				for (int j = l; j <= r; ++j) {
					ans[i] += BLK::query(p[j]);
				}
				continue;
			}
			for (int j = l; j <= R[bel[l]]; ++j) {
				ans[i] += BLK::query(p[j]);
			}
			for (int j = L[bel[r]]; j <= r; ++j) {
				ans[i] += BLK::query(p[j]);
			}
		}
	}
	for (int k = 1; k <= bel[n]; ++k) {
		mems(d, 0);
		for (int i = L[k]; i <= R[k]; ++i) {
			d[p[i]] = 1;
		}
		for (int i = 1; i <= n; ++i) {
			d[i] += d[i - 1];
		}
		ull s = 0;
		for (int i = 1; i <= m; ++i) {
			for (pii _ : S[i]) {
				s += (d[_.scd] - d[_.fst - 1]) * b[i].k;
			}
			for (pii _ : T[i]) {
				int l = _.fst, r = _.scd;
				if (bel[l] < k && k < bel[r]) {
					ans[i] += s;
				}
			}
		}
	}
	for (int i = 1; i <= m; ++i) {
		printf("%llu\n", ans[i]);
	}
}

int main() {
	int T = 1;
	// scanf("%d", &T);
	while (T--) {
		solve();
	}
	return 0;
}