#include <bits/stdc++.h>
using namespace std;
#define Foreach(i, c) for(__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define For(i,a,b) for(int (i)=(a);(i) < (b); ++(i))
#define rof(i,a,b) for(int (i)=(a);(i) > (b); --(i))
#define rep(i, c)  for(auto &(i) : (c))
#define x     first
#define y     second
#define pb  push_back
#define PB  pop_back()
#define iOS  ios_base::sync_with_stdio(false)
#define sqr(a)  (((a) * (a)))
#define all(a)  a.begin() , a.end()
#define error(x) cerr << #x << " = " << (x) <<endl
#define Error(a,b) cerr<<"( "<<#a<<" , "<<#b<<" ) = ( "<<(a)<<" , "<<(b)<<" )\n";
#define errop(a) cerr<<#a<<" = ( "<<((a).x)<<" , "<<((a).y)<<" )\n";
#define coud(a,b) cout<<fixed << setprecision((b)) << (a)
#define L(x)  ((x)<<1)
#define R(x)  (((x)<<1)+1)
#define umap  unordered_map
//#define max(x,y)  ((x) > (y) ? (x) : (y))
#define double long double
typedef long long ll;
typedef pair<int,int>pii;
typedef vector<int> vi;
typedef pair<long long,long long> PLL;
const int maxn = 1e5 + 100;
const int maxl = 20;
int sz[maxn], f[maxn], par[maxn][maxl], h[maxn];
vi adj[maxn], adw[maxn];
int chn[maxn];
int w[maxn];
struct node{
	ll p,s,tot,cnt;
	node(){
		cnt = p = s = tot = 0LL;
	}
	node(int x){
		tot = 0LL;
		p = s = cnt = x;
	}
	inline bool ish(){
		return (cnt == p && p && s);
	}
	inline node operator * (node a){
		node ans;
		ans.cnt = a.cnt + cnt;
		bool h = ish(), H = a.ish();
		ans.tot = a.tot + tot;
		if(!h && !H){
			ans.tot += f[s + a.p];
			ans.p = p;
			ans.s = a.s;
		}
		else if(!h && H){
			ans.p = p;
			ans.s = s + a.s;
		}
		else if(h && !H){
			ans.p = p + a.p;
			ans.s = a.s;
		}
		else{
			ans.p = ans.s = p + a.p;
		}
		return ans;
	}
	inline ll score(){
		ll ans = tot + f[p];
		if(!ish())
			ans += f[s];
		return ans;
	}
	inline node reverse(){
		node ans;
		ans.p = s;
		ans.s = p;
		ans.tot = tot;
		ans.cnt = cnt;
		return ans;
	}
};
struct seg{
	vector<node> s;
	int sz;
	seg(){
	sz = 0;}
	seg(int n){
		while(s.size() < 4 * n)
			s.pb(node());
		sz = n;
	}
	inline void add(int p,int id,int l,int r){
		if(r - l < 2){
			s[id] = node(1);
			return ;
		}
		int mid = (l+r)/2;
		if(p < mid)
			add(p, L(id), l, mid);
		else
			add(p, R(id), mid, r);
		s[id] = s[L(id)] * s[R(id)];
	}
	inline node get(int x,int y,int id,int l,int r){
		if(x <= l && r <= y)
			return s[id];
		int mid = (l+r)/2;
		if(y <= mid)
			return get(x, y, L(id), l, mid);
		else if(mid <= x)
			return get(x, y, R(id), mid, r);
		return get(x, y, L(id), l, mid) * get(x, y, R(id), mid, r);
	}
	inline void ADD(int p){
		add(p, 1, 0, sz);
	}
	inline node score(int x,int y){
		return get(x, y, 1, 0, sz);
	}

};
struct query{
	int ind, mnh, mxh, l;
	query(){
	}
	query(int a,int b,int c,int d){
		ind = a;
	 	mnh = b;
		mxh = c;
		l = d;
	}
};
inline bool qcmp (const query &a, const query & q){
		return a.l < q.l;
	}
inline bool cmp(const pii &p, const pii &q){
	if(p.y - q.y)
		return p.y > q.y;
	return p.x < q.x;
}
struct chain{
	int X,x,y;
	seg s;
	umap <int, node> MP;
	chain(){}
	chain(int a,int b): X(a), y(b){}
	chain(int a,int b,int c): X(a), x(b), y(c){}
	vector<pii> vpn;
	vector<query> QQ;
	inline void proc(int i){
		int v = y;
		while(v != X){
			if(par[v][0] == X)
				x = v;
			vpn.pb({h[v], w[v]});
			chn[v] = i;
			v = par[v][0];
		}
		sort(all(vpn));
	}
	inline void solve(){
		sort(all(QQ), qcmp);
		s = seg(vpn.size());
		vector<pii> vs = vpn;
		sort(all(vs), cmp);
		reverse(all(QQ));
		int po = 0;
		rep(q, QQ){
			while(po < vs.size() && vs[po].y >= q.l){
				int i = lower_bound(all(vpn), pii(vs[po].x, -1)) -  vpn.begin();
				s.ADD(i);
				po ++;
			}
			int l = lower_bound(all(vpn), pii(q.mnh, -1)) -  vpn.begin();
			int r = upper_bound(all(vpn), pii(q.mxh, 1e9)) -  vpn.begin();
			MP[q.ind] = s.score(l, r);
		}
	}
};
vector<chain> HLD;
inline int dfs(int v = 0,int p = -1){
	if(p + 1)
		h[v] = h[p] + 1;
	par[v][0] = p;
	For(i,1,maxl)	if(par[v][i-1] + 1)
		par[v][i] = par[par[v][i-1]][i-1];
	sz[v] = 1;
	For(i,0,adj[v].size()){
		int u = adj[v][i];
		if(u - p){
			w[u] = adw[v][i];
			sz[v] += dfs(u, v);
		}
	}
	return sz[v];
}
inline void prepHLD(int v = 0,bool h = 0,int f = -1){
	if(f == -1){
		if(par[v][0] != -1)
			f = par[v][0];
		else
			f = v;
	}
	bool hh = 0, ch = 0, is = 0;
		rep(u, adj[v]){
			if(u - par[v][0] && sz[u] * 2 >= sz[v])
				hh = 1;
			if(u - par[v][0])
				ch = 1;
		}
	if(par[v][0] != -1){
		if(h && !hh && !ch)
			HLD.pb(chain(f,v));
		if(!h && !ch)
			HLD.pb(chain(par[v][0],v));
	}
	rep(u, adj[v])
		if(u - par[v][0]){
			if(sz[u] * 2 < sz[v]){
				if(!is && !hh)
					prepHLD(u,1,f);
				else
					prepHLD(u);
			}
			else
				prepHLD(u,1,f);
			is = 1;
		}
}
inline int lca(int v,int u){
	if(h[u] > h[v])
		swap(v, u);
	rof(i, maxl - 1, -1)
		if(par[v][i] + 1 && h[par[v][i]] >= h[u])
			v = par[v][i];
	if(v == u)	return v;
	rof(i, maxl - 1, -1)
		if(par[v][i] - par[u][i])
			v = par[v][i], u = par[u][i];
	return par[v][0];
}
inline vi dec(int v,int H){
	vi ans;
	while(v + 1 && h[v] > H){
		ans.pb(chn[v]);
		v = HLD[chn[v]].X;
	}
	return ans;
}
inline vi decompose(int v,int u){
	int x = lca(v, u);
	int H = h[x];
	vi ans = dec(v, H);
	vi V = dec(u, H);
	reverse(all(V));
	rep(w, V)
		ans.pb(w);
	return ans;
}
stringstream ss;
inline void prepQ(int i,int v,int w,int l){
	while(v + 1 && h[v] > h[w]){
		int j = chn[v];
		int mnh = h[w] + 1;
		int mxh = h[v];
		HLD[j].QQ.pb(query(i, mnh, mxh, l));
		v = HLD[chn[v]].X;
	}
}
inline void prepq(int i,int v,int u,int l){
	ss << v << ' ' << u << ' ' << l << '\n';
	int w = lca(v, u);
	prepQ(i, v, w, l);
	prepQ(i, u, w, l);
}
int IND;
inline ll ANS(){
	int v,u,l;
	ss >> v >> u >> l;
	int w = lca(v, u);
	vi V = decompose(v, w);
	vi U = decompose(w, u);
	node N(0);
	rep(c, V)
		N = N * HLD[c].MP[IND].reverse();//, error(HLD[c].MP[IND].reverse().cnt);
	rep(c, U){
		N = N * HLD[c].MP[IND];
	/*	error(HLD[c].MP[IND].cnt);
		error(HLD[c].MP[IND].p);
		error(HLD[c].MP[IND].s);
		error(HLD[c].y);*/

	}
	IND ++;
	//Error(N.s, N.p);
	//error(N.cnt);
	return N.score();
}
int n,q;
int main(){
	memset(par, -1, sizeof(par));
	iOS;
	cin >> n >> q;
	For(i,1,n)
		cin >> f[i];
	int v,u,w;
	For(i,1,n){
		cin >> v >> u >> w;
		-- v, -- u;
		adj[v].pb(u);
		adj[u].pb(v);
		adw[v].pb(w);
		adw[u].pb(w);
	}
	dfs();
	prepHLD();
	For(i,0,HLD.size())
		HLD[i].proc(i);
	//error(HLD.size());
	For(i,0,q){
		cin >> v >> u >> w;
		-- v, -- u;
		prepq(i, v, u, w);
	}
	For(i,0,HLD.size())
		HLD[i].solve();
	For(i,0,q)
		cout << ANS() << '\n';

}