AC了前三组。 RE了后七组 改大(define long long le)点后就WA了后七组了。。

#include<iostream>
#include<vector>
#include<cstdio>
#define rep(i,j,k) for(register int i(j);i<=k;++i)
#define drp(i,j,k) for(register int i(j);i>=k;--i)
#define bug cout<<"~~~~~~~~~~~~~"<<'\n';
#define bugout(x) cout<<x<<'\n';
using std::cin;
using std::cout;
typedef long long lxl;
template<typename T>
inline T  max( T a, T b) {
	return a > b ? a : b;
}
template<typename T>
inline T  min( T a, T b) {
	return a < b ? a : b;
}

inline char gt() {
	static char buf[1 << 21], *p1 = buf, *p2 = buf;
	return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++;
}
template <typename T>
inline void  read(T &x) {
	register char ch = gt();
	x = 0;
	int w(0);
	while(!(ch >= '0' && ch <= '9'))w |= ch == '-', ch = gt();
	while(ch >= '0' && ch <= '9')x = x * 10 + (ch & 15), ch = gt();
	w ? x = ~(x - 1) : x;
}
using std::swap;
template <typename T>
inline void out(T x, char cc) {
	if(x < 0) x = -x, putchar('-');
	char ch[20];
	int num(0);
	while(x || !num) ch[++num] = x % 10 + '0', x /= 10;
	while(num) putchar(ch[num--]);
	putchar(cc);
}
const int N = 5e5 + 79;
#define int long long
int n, q;
int a[N], b[N];
using std::vector;
vector<int> v[N];

int son[N], dfn[N], siz[N], tim, dep[N], fa[N], top[N];
inline void dfs1(int x) {
	dfn[x] = ++tim;
	b[tim] = a[x];
	dep[x] = dep[fa[x]] + 1;
	siz[x] = 1;
	int t(v[x].size() - 1);
	rep(i, 0, t) {
		int y(v[x][i]);
		if(y == fa[x]) continue;
		fa[y] = x;
		dfs1(y);
		siz[x] += siz[y];
		if(siz[y] > siz[son[x]]) son[x] = y;
	}
}
inline void dfs2(int x, int topf) {
	top[x] = topf;
	if(son[x]) dfs2(son[x], topf);
	int t(v[x].size() - 1);
	rep(i, 0, t) {
		int y(v[x][i]);
		if(y != fa[x] && y != son[x]) dfs2(y, y);
	}
}



struct node {
	int lmax, rmax, tag, max, min;
	node(){
		lmax=rmax=tag=max=min=0;
	}//³õʼ»¯£¡£¡ 
} p[N << 2];
inline node merge(node a, node b) {
	node ans;
	ans.max = max(a.max, b.max);
	ans.min = min(a.min, b.min);
	ans.lmax = max(max(a.lmax, b.lmax), a.max - b.min); //´Ó×ó±ß¿ªÊ¼×ßµÄ×î´óÖµ
	ans.rmax = max(max(a.rmax, b.rmax), b.max - a.min);
	return ans;
}
struct SegmentTree {

	int lc[N], rc[N], cnt, rt;
    
    inline void pushup(int x){
    	node ans=merge(p[lc[x]],p[rc[x]]);
    	ans.tag=p[x].tag;
    	p[x]=ans;
	}
    
	inline void pushdown(int x) {
		if(!p[x].tag)return;

		p[lc[x]].max += p[x].tag;
		p[lc[x]].min += p[x].tag;
		p[rc[x]].max += p[x].tag;
		p[rc[x]].min += p[x].tag;

		p[lc[x]].tag += p[x].tag;
		p[rc[x]].tag += p[x].tag;
		p[x].tag = 0;
	}
	inline void build(int &x, int L, int R) {
		if(!x) x = ++cnt;
		if(L == R) {
			p[x].max = p[x].min = b[L];
			return ;
		}
		int mid(L + R >> 1);
		build(lc[x], L, mid);
		build(rc[x], mid + 1, R);
		pushup(x);
	}
	inline void change(int x, int L, int R, int ll, int rr, int val) {
		if(L >= ll && rr >= R) {
			p[x].max += val;
			p[x].min += val;
			p[x].tag += val;
			return;
		}
		pushdown(x);
		int mid(L + R >> 1);
		if(ll <= mid) change(lc[x], L, mid, ll, rr, val);
		if(rr > mid) change(rc[x], mid + 1, R, ll, rr, val);
		pushup(x);
	}
	inline node query(int x, int L, int R, int ll, int rr) {
		if(ll <= L && rr >= R) {
			return p[x];
		}
		pushdown(x);
		int mid(L + R >> 1);
		if(ll > mid) return query(rc[x], mid + 1, R, ll, rr);
		else if(rr <= mid) return query(lc[x], L, mid, ll, rr);
		else return merge(query(lc[x], L, mid, ll, rr), query(rc[x], mid + 1, R, ll, rr));
	}
} S;

inline void Cchain(int x, int y, int k) {
	while(top[x]^top[y]) {
		if(dep[top[x]] < dep[top[y]]) swap(x, y);
		S.change(S.rt, 1, n, dfn[top[x]], dfn[x], k);
		x = fa[top[x]];
	}
	if(dep[x] > dep[y]) swap(x, y);
	S.change(S.rt, 1, n, dfn[x], dfn[y], k);
}

inline int Qchain(int x, int y) {
	node l, r;
	l.min = r.min = 2e9;
	while(top[x]!=top[y]) {
		if(dep[top[x]] < dep[top[y]]) {
			r = merge(S.query(S.rt, 1, n, dfn[top[y]], dfn[y]), r); //×¢Òâ±äÁ¿Î»ÖÃ
			y = fa[top[y]];
		} else {
			l = merge(S.query(S.rt, 1, n, dfn[top[x]], dfn[x]), l);
			x = fa[top[x]];
		}
	}
	if(dfn[x] > dfn[y]) l = merge(S.query(S.rt, 1, n, dfn[y], dfn[x]), l);
	else r = merge(S.query(S.rt, 1, n, dfn[x], dfn[y]), r);

	swap(l.lmax, l.rmax);
	return merge(l, r).rmax;
}

 main() {
	read(n);
	rep(i, 1, n) {
		read(a[i]);
	}
	int x, y, z;
	rep(i, 2, n) {
		read(x);
		read(y);
		v[x].push_back(y);
		v[y].push_back(x);
	}
	dfs1(1);
	dfs2(1, 1);
/*
3
1 2 3
1 2
2 3
*/

	S.build(S.rt, 1, n);
//	Cchain(1,2,100);
//	cout<<Qchain(1,2)<<'\n';
//	return 0;
//	
	read(q);
	while(q--) {
		read(x);
		read(y);
		read(z);
		out(Qchain(x, y), '\n');
		Cchain(x, y, z);
	}
	
	return 0;
}
/*
3
1 2 3
1 2
2 3
2
1 2 100
1 3 100

*/