其實真實做法是倍增 ，但為了練習就用 $ddp$寫了 $qwq$

最小覆蓋集= $sum-$最大獨立集

然後就是裸 $d$

但是他有兩個點的強制要求，如果強制不選就可以把權值改成 $inf$

注意開LL

程式碼如下：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#define LL long long
#define N 100005
#define ls cur<<1
#define rs cur<<1|1
#define inf 0x3f3f3f3f3f3f3f3f
using namespace std;

inline int rd(){
	int x=0,f=1;char c=' ';
	while(c<'0' || c>'9') f=c=='-'?-1:1,c=getchar();
	while(c<='9' && c>='0') x=x*10+c-'0',c=getchar();
	return x*f;
}

int n,m,cnt,head[N],to[N<<1],nxt[N<<1];
int num,siz[N],dep[N],son[N],top[N],fa[N],dfn[N],rk[N],ed[N];
LL sum,f[N][2],a[N];
char useless[10];

inline void add(int x,int y){to[++cnt]=y;nxt[cnt]=head[x];head[x]=cnt;}

void dfs1(int u,int fat){
	siz[u]=1; int maxson=-1;
	for(int i=head[u];i;i=nxt[i]){
		int v=to[i]; if(v==fat) continue;
		dep[v]=dep[u]+1; fa[v]=u;
		dfs1(v,u); siz[u]+=siz[v];
		if(siz[v]>maxson) maxson=siz[v],son[u]=v;
	}
}

void dfs2(int u,int t){
	top[u]=t; dfn[u]=++num; rk[num]=u; ed[t]=u;
	if(!son[u]) return; dfs2(son[u],t);
	for(int i=head[u];i;i=nxt[i]){
		int v=to[i];
		if(!dfn[v]) dfs2(v,v);
	}
}

void DP(int u,int fat){
	f[u][1]=a[u];
	for(int i=head[u];i;i=nxt[i]){
		int v=to[i]; if(v==fat) continue;
		DP(v,u);
		f[u][1]+=f[v][0]; f[u][0]+=max(f[v][0],f[v][1]);
	}
}

struct Mat{
	LL g[2][2];
	Mat(){memset(g,0,sizeof g);}
	Mat operator *(const Mat &x) const{
		Mat ret;
		for(int i=0;i<2;i++)
			for(int j=0;j<2;j++)
				for(int k=0;k<2;k++)
				ret.g[i][j]=max(ret.g[i][j],g[i][k]+x.g[k][j]);
		return ret;
	}
}val[N],node[N<<2];

void build(int cur,int L,int R){
	if(L==R){
		LL g0=0,g1=a[rk[L]];
		for(int u=rk[L],v,i=head[u];i;i=nxt[i])
			if((v=to[i])!=fa[u] && v!=son[u])
				g0+=max(f[v][0],f[v][1]),g1+=f[v][0];
		node[cur].g[0][0]=node[cur].g[0][1]=g0;
		node[cur].g[1][0]=g1; node[cur].g[1][1]=-inf;
		val[L]=node[cur]; return;
	}
	int mid=(L+R)>>1;
	build(ls,L,mid); build(rs,mid+1,R);
	node[cur]=node[ls]*node[rs];
}

void update(int cur,int L,int R,int p){
	if(L==R) {node[cur]=val[L];return;}
	int mid=(L+R)>>1;
	if(p<=mid) update(ls,L,mid,p);
	else update(rs,mid+1,R,p);
	node[cur]=node[ls]*node[rs];
}

Mat query(int cur,int L,int R,int ql,int qr){
	if(ql<=L && R<=qr) return node[cur];
	int mid=(L+R)>>1;
	if(qr<=mid) return query(ls,L,mid,ql,qr);
	if(ql>mid) return query(rs,mid+1,R,ql,qr);
	return query(ls,L,mid,ql,qr)*query(rs,mid+1,R,ql,qr);
}

inline Mat ask(int u){return query(1,1,n,dfn[u],dfn[ed[u]]);}

inline void change(int u,LL x){
	val[dfn[u]].g[1][0]+=x-a[u]; a[u]=x;
	Mat pre,now;
	while(u){
		pre=ask(top[u]);
		update(1,1,n,dfn[u]);
		now=ask(top[u]);
		u=fa[top[u]];
		val[dfn[u]].g[0][0]+=max(now.g[0][0],now.g[1][0])-max(pre.g[0][0],pre.g[1][0]);
		val[dfn[u]].g[0][1]=val[dfn[u]].g[0][0];
		val[dfn[u]].g[1][0]+=now.g[0][0]-pre.g[0][0];
	}
}

inline void prework(){dfs1(1,0);dfs2(1,1);DP(1,0);build(1,1,n);}

int x,y,A,B;
LL prex,prey,tmp;

int main(){
	n=rd(); m=rd(); scanf("%s",useless);
	for(int i=1;i<=n;i++) a[i]=rd(),sum+=a[i];
	for(int i=1;i<n;i++){
		x=rd(),y=rd();
		add(x,y); add(y,x);
	}
	prework();
	while(m--){
		x=rd(),A=rd(),y=rd(),B=rd();
		if(A==0 && B==0 && (fa[x]==y||fa[y]==x)) {puts("-1");continue;}
		prex=a[x],prey=a[y]; tmp=0;
		if(A==0) change(x,inf),tmp+=inf-prex; else change(x,-inf);
		if(B==0) change(y,inf),tmp+=inf-prey; else change(y,-inf);
		Mat ans=ask(1);
		printf("%lld\n",sum-max(ans.g[0][0],ans.g[1][0])+tmp);
		change(x,prex); change(y,prey);
	}
	return 0;
}