直接做的，没用最小点覆盖 = 总点权 - 最大独立集。

#include<cstdio>
#include<algorithm>
#include<cmath>
#include<iostream>
#include<set>
#include<vector>
#include<queue>
#include<stack>
#include<cstring>
#include<cstdlib>
#include<ctime>
#define rep(i,a,b) for(register int i=a;i<=b;++i)
#define rev(i,a,b) for(register int i=a;i>=b;--i)
#define gra(i,u) for(register int i=head[u];i;i=edge[i].nxt)
#define Clear(a) memset(a,0,sizeof(a))
#define yes puts("YES")
#define no puts("NO")
using namespace std;
typedef long long ll;
const int INF(1e9+10);
const ll LLINF(1e14+10);
inline int read()
{
    int s=0,w=1;
    char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
    while(ch>='0'&&ch<='9')s=s*10+(ch-'0'),ch=getchar();
    return s*w;
}
template<typename T>
inline T Min(T x,T y){return x<y?x:y;}
template<typename T>
inline T Max(T x,T y){return x>y?x:y;}
template<typename T>
inline void Swap(T&x,T&y){T t=x;x=y;y=t;return;}
template<typename T>
inline T Abs(T x){return x<0?-x:x;}

const int MAXN(1e5+10);

int n,a[MAXN],m;

struct E{int to,nxt;};
E edge[MAXN<<1];
int head[MAXN],tot;

inline void add_edge(int u,int v){edge[++tot].nxt=head[u];head[u]=tot;edge[tot].to=v;return;}

struct Matrix
{
	ll G[3][3];
	Matrix(){rep(i,1,2) rep(j,1,2) G[i][j]=LLINF;return;}
	inline Matrix operator*(const Matrix&x)
	{
		Matrix res;
		rep(i,1,2) rep(j,1,2) rep(k,1,2) res.G[i][j]=Min(res.G[i][j],G[i][k]+x.G[k][j]);
		return res;
	}
};
Matrix val[MAXN];
ll f[MAXN][2];

int siz[MAXN],son[MAXN],par[MAXN],cnt,idx[MAXN],rk[MAXN],top[MAXN],lst[MAXN];
char zyyismine[666];

inline void dfs1(int u,int fa)
{
	par[u]=fa,siz[u]=1;
	gra(i,u)
	{
		int v=edge[i].to;
		if(v!=fa)
		{
			dfs1(v,u);
			siz[u]+=siz[v];
			if(siz[v]>siz[son[u]]) son[u]=v;
		}
	}
	return;
}

inline void dfs2(int u,int topf)
{
	idx[u]=++cnt;
	rk[cnt]=u,top[u]=topf,lst[topf]=Max(lst[topf],cnt);

	f[u][0]=0,f[u][1]=a[u];
	val[u].G[1][2]=0,val[u].G[2][1]=a[u],val[u].G[2][2]=a[u];

	if(son[u])
	{
		dfs2(son[u],topf);
		f[u][0]+=f[son[u]][1];
		f[u][1]+=Min(f[son[u]][0],f[son[u]][1]);
	}

	gra(i,u)
	{
		int v=edge[i].to;
		if(v!=par[u]&&v!=son[u])
		{
			dfs2(v,v);
			f[u][0]+=f[v][1];
			f[u][1]+=Min(f[v][0],f[v][1]);
			val[u].G[1][2]+=f[v][1];
			val[u].G[2][1]+=Min(f[v][0],f[v][1]),val[u].G[2][2]=val[u].G[2][1];
		}
	}
	return;
}

struct Segment_Tree
{
	Matrix tree[MAXN*4];

	inline int lc(int p){return p<<1;}
	inline int rc(int p){return p<<1|1;}

	inline void push_up(int u)
	{
		tree[u]=tree[lc(u)]*tree[rc(u)];
		return;
	}

	inline void build(int u,int l,int r)
	{
		if(l==r)
		{
			tree[u]=val[rk[l]];
			return;
		}
		int mid=(l+r)>>1;
		build(lc(u),l,mid),build(rc(u),mid+1,r);
		push_up(u);
		return;
	}

	inline void update(int u,int l,int r,int p)
	{
		if(l==r)
		{
			tree[u]=val[rk[p]];
			return;
		}
		int mid=(l+r)>>1;
		if(p<=mid) update(lc(u),l,mid,p);
		else update(rc(u),mid+1,r,p);
		push_up(u);
		return;
	}

	inline Matrix query(int u,int l,int r,int ln,int rn)
	{
		if(ln<=l&&r<=rn) return tree[u];
		int mid=(l+r)>>1;
		if(rn<=mid) return query(lc(u),l,mid,ln,rn);
		else if(ln>mid) return query(rc(u),mid+1,r,ln,rn);
		else return query(lc(u),l,mid,ln,rn)*query(rc(u),mid+1,r,ln,rn); 
	}
};
Segment_Tree seg;

inline void modify(int u,ll v)
{
	val[u].G[2][1]+=v,val[u].G[2][2]+=v;
	Matrix g1,g2;
	while(u)
	{
		g1=seg.query(1,1,n,idx[top[u]],lst[top[u]]);
		seg.update(1,1,n,idx[u]);
		g2=seg.query(1,1,n,idx[top[u]],lst[top[u]]);
		u=par[top[u]];
		val[u].G[1][2]+=g2.G[1][2]-g1.G[1][2];
		val[u].G[2][1]+=Min(g2.G[1][1],g2.G[2][1])-Min(g1.G[1][1],g1.G[2][1]);
	}
	return;
}

int main()
{
    freopen("read.txt","r",stdin);
    n=read(),m=read(),scanf("%s",zyyismine);
    rep(i,1,n) a[i]=read();
    rep(i,2,n)
    {
    	int u=read(),v=read();
    	add_edge(u,v),add_edge(v,u);
    }
    dfs1(1,0),dfs2(1,1);
    seg.build(1,1,n);
    while(m--)
    {
    	int u=read(),a=read(),v=read(),b=read();
    	if(u==par[v]||v==par[u])
    	{
    		puts("-1");
    		continue;
    	}
    	if(!a) modify(u,LLINF);
    	else modify(u,-LLINF);
    	if(!b) modify(v,LLINF);
    	else modify(v,-LLINF);

    	puts("N1:");

    	rep(i,1,n) printf("%lld ",val[i].G[2][1]);
    	puts("");

    	Matrix now=seg.query(1,1,n,idx[1],lst[1]);
    	ll ans=Min(now.G[1][1],now.G[2][1]);
        
    	if(!a) modify(u,-LLINF);
    	else modify(u,LLINF),ans+=LLINF;
    	if(!b) modify(v,-LLINF);
    	else modify(v,LLINF),ans+=LLINF;
    	printf("%lld\n",ans);

    	puts("N2:");

    	rep(i,1,n) printf("%lld ",val[i].G[2][1]);
    	puts("");
    }
    return 0;
}
/*
Date : 2022/9/28
Author : UperFicial
Start coding at : 18:47
finish debugging at :
*/