窝当然不会ddp啦，要写这题当然是考虑优化裸dp啦，但是这题非常麻烦，于是变成了黑题。
首先，这个是没有上司的舞会模型，求图的带权最大独立集。
不考虑国王的限制条件，有
\[
dp[x][0]+=dp[y][1]\\
dp[x][1]+=min(dp[y][1],dp[y][0])
\]
现在考虑限制条件，如果对每一个限制条件都做一次dp，复杂度达到\(O(n^2)\)，无法承受。
显然，对于这些限制条件，每一次的变动不会影响其它大多数的状态。
对于一个限制条件，我们分开考虑，先考虑只对一个城市进行限制的情况。
若该城市被要求驻扎军队，那么如果在最优情况下它本来就需要军队，则没有影响；如果它本来不需要军队，由于此时所有子树都是最优解，那么它只会对从它到根节点的路径的最优解产生影响。
若该城市被要求不能驻扎，那么与上面的情况类似，如果它本来需要驻扎，那么会对它到根节点的路径造成影响。
综上所述，我们是否可以考虑对于每个限制条件，只对两个点到根节点之间的路径的某些状态进行修改呢？答案是肯定的。
假设待修改节点为\(x\)。首先，此时除了\(x\sim root\)的路径上的节点所表示的状态，其它状态都是最优的。对于这条路径的更新，实际上就是又对这条路径做了一次dp，并强制\(x\)选或不选，从而限制转移。
显然这是可行的，但是复杂度仍为\(O(n^2)\)，我们需要一些手段进行优化。
容易发现我们更新的是一条链，对于一条链，我们自然可以想到用倍增或者树剖（它们维护的都是树链）来处理每个点的转移。
以倍增为例。
首先考虑裸dp的步骤，一个一个跳，每次从儿子转移。那我们能不能一段一段地跳，每次从已有信息中转移呢？当然可以。
先考虑只有一个点的情况。
如果我们要对\(x\)进行限制，那么我们不妨把整个图变成这样，方便分析
其中绿色的部分是\(x\)的子树的最优解。
显然我们在修改一个点之后，造成的对原最优解的影响是一定的，产生的新最优解是一定的，这意味着我们可以通过一些手段预处理出来。
不妨考虑通过倍增预处理出最优情况下每个点产生变动（选变成不选，不选变成选）在这条\(x\sim root\)的链上产生的新最优解，也就是预处理出修改后dp时跳某一段的该段最优解。
然后从\(x\)树上倍增跳到\(root\)，合并所得的新的最优解，就是这次限制条件下的答案。
实际上，我们的倍增预处理是在一次裸dp的基础上进行的。换句话说，倍增时用到的信息就是每个点表示的状态的原来的最优解，然后加一个限制条件，再做一个dp。
形象的讲，这个倍增预处理，就是dp套dp。
那这个倍增怎么做呢？
考虑状态的刻画，显然由几个较小的子问题合并成较大的子问题时，这些较小的子问题不能有交叉，否则无法基于二进制划分合并成更大的子问题。再者，子问题必须覆盖整个状态空间。也就是说，在状态定义时，我们要不重不漏。
既然如此，对于第一点，不难想到倍增时我们不仅要记录\(x\)的状态（0/1），还要记录它跳\(2^k\)步的祖先的状态。
对于第二点，不难想出状态包含的范围。
设\(f[0/1][0/1][k][x]\)表示\(x\)节点变为0不可选、1可选时，向上\(2^k\)步的祖先\(y\)为0可选、1不可选时，\(y\)除去\(x\)以及\(x\)的子树的原最优解的其它所有子树的新最优解。
如下图，假设节点3是\(x\)的\(2^k\)祖先，状态为红色部分
而3的\(2^k\)祖先（假设是\(root\)）表示的状态就是蓝色部分。
这样就可以很好的合并状态，之后统计答案的过程中，我们只需枚举\(x\)的状态并倍增跳即可。
对于节点\(y\)，它的父节点为\(x\)，有
\[
f[1][0][0][y]=dp[0][x]-dp[1][y]\\ f[0][1][0][y]=f[1][1][0][y]=dp[1][x]-min(dp[1][y],dp[0][y])
\]
得到转移（cao）
\[
f[0][0][j][y]=min(f[0][0][j-1][y]+f[0][0][j-1][fa],f[0][1][j-1][y]+f[1][0][j-1][fa])\\
f[0][1][j][y]=min(f[0][0][j-1][y]+f[0][1][j-1][fa],f[0][1][j-1][y]+f[1][1][j-1][fa])\\
f[1][0][j][y]=min(f[1][0][j-1][y]+f[0][0][j-1][fa],f[1][1][j-1][y]+f[1][0][j-1][fa])\\
f[1][1][j][y]=min(f[1][0][j-1][y]+f[0][1][j-1][fa],f[1][1][j-1][y]+f[1][1][j-1][fa])
\]
然后就是统计答案，当然是倍增统计答案。
从待修改点的两种不同状态开始往上倍增合并新最优解，直到根节点。
对于两个待修改点\(x,y\)的情况，我们像求LCA一样，先统计\(x\sim lca(x,y),y\sim lca(x,y)\)，再统计\(lca(x,y)\sim root\)即可。
注意一个细节，当\(x,y\)两点跳到\(lca\)的儿子处我们需要同时减去它们两个的原最优解，再往上跳。
复杂度降至\(O(nlogn)\)。
树剖也是一个道理，预处理变动后最优解。
参考代码
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<string>
#include<cstdlib>
#include<queue>
#include<vector>
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
#define N 100010
#define MOD 2520
#define E 1e-12
#define ll long long
using namespace std;
inline ll read()
{
ll f=1,x=0;char c=getchar();
while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
return x*f;
}
struct rec{
int next,ver;
}g[N<<1];
int head[N],tot,n,m;
ll dp[2][N],f[2][2][21][N],gi[21][N],t,dep[N],w[N];
inline void add(int x,int y)
{
g[++tot].ver=y;
g[tot].next=head[x],head[x]=tot;
}
inline void dfs(int x,int fa)
{
dp[1][x]=w[x];dep[x]=dep[fa]+1;
f[0][0][0][x]=INF,gi[0][x]=fa;
for(int j=1;j<t;++j) gi[j][x]=gi[j-1][gi[j-1][x]];
for(int i=head[x];i;i=g[i].next){
int y=g[i].ver;
if(y==fa) continue;
dfs(y,x);
dp[0][x]+=dp[1][y];
dp[1][x]+=min(dp[1][y],dp[0][y]);
}
}
inline void init()
{
queue<ll> q;
q.push(1);
f[1][0][0][1]=dp[0][0]-dp[1][1];
f[0][1][0][1]=f[1][1][0][1]=dp[1][0]-min(dp[1][1],dp[0][1]);
while(q.size()){
ll x=q.front();q.pop();
for(int i=head[x];i;i=g[i].next){
int y=g[i].ver;
if(y==gi[0][x]) continue;
f[1][0][0][y]=dp[0][x]-dp[1][y];
f[0][1][0][y]=f[1][1][0][y]=dp[1][x]-min(dp[1][y],dp[0][y]);
for(int j=1;j<t;++j){
int fa=gi[j-1][y];
f[0][0][j][y]=min(f[0][0][j-1][y]+f[0][0][j-1][fa],f[0][1][j-1][y]+f[1][0][j-1][fa]);
f[0][1][j][y]=min(f[0][0][j-1][y]+f[0][1][j-1][fa],f[0][1][j-1][y]+f[1][1][j-1][fa]);
f[1][0][j][y]=min(f[1][0][j-1][y]+f[0][0][j-1][fa],f[1][1][j-1][y]+f[1][0][j-1][fa]);
f[1][1][j][y]=min(f[1][0][j-1][y]+f[0][1][j-1][fa],f[1][1][j-1][y]+f[1][1][j-1][fa]);
}
q.push(y);
}
}
}
inline ll get(ll x,int a,ll y,int b)
{
ll ans=0,lca;
if(dep[x]<dep[y]) swap(x,y),swap(a,b);
ll x0=INF,x1=INF,y0=INF,y1=INF,l0=INF,l1=INF;
a?x1=dp[1][x]:x0=dp[0][x],b?y1=dp[1][y]:y0=dp[0][y];
for(int j=t;j>=0;--j){
ll t0=x0,t1=x1;
if(dep[gi[j][x]]>=dep[y]){
x0=min(t0+f[0][0][j][x],t1+f[1][0][j][x]);
x1=min(t0+f[0][1][j][x],t1+f[1][1][j][x]);
x=gi[j][x];
}
}
if(x==y) lca=x,b?l1=x1:l0=x0;
else {
for(int j=t;j>=0;--j){
if(gi[j][x]!=gi[j][y]){
ll t0=x0,t1=x1,p0=y0,p1=y1;
x0=min(t0+f[0][0][j][x],t1+f[1][0][j][x]);
x1=min(t0+f[0][1][j][x],t1+f[1][1][j][x]);
y0=min(p0+f[0][0][j][y],p1+f[1][0][j][y]);
y1=min(p0+f[0][1][j][y],p1+f[1][1][j][y]);
x=gi[j][x],y=gi[j][y];
}
}
lca=gi[0][x];
l0=dp[0][lca]-dp[1][x]-dp[1][y]+x1+y1;
l1=dp[1][lca]-min(dp[0][x],dp[1][x])-min(dp[0][y],dp[1][y])+min(x1,x0)+min(y1,y0);
}
if(lca==1) ans=min(l0,l1);
else{
for(int j=t;j>=0;--j){
if(dep[gi[j][lca]]>1){
ll t0=l0,t1=l1;
l0=min(t0+f[0][0][j][lca],t1+f[1][0][j][lca]);
l1=min(t0+f[0][1][j][lca],t1+f[1][1][j][lca]);
lca=gi[j][lca];
}
}
ans=min(dp[0][1]-dp[1][lca]+l1,dp[1][1]-min(dp[0][lca],dp[1][lca])+min(l1,l0));
}
return ans<INF?ans:-1;
}
int main()
{
n=read(),m=read();
char op[5];
cin>>op;
t=log2(n)+1;
for(int i=1;i<=n;++i) w[i]=read();
for(int i=1;i<n;++i){
ll u=read(),v=read();
add(u,v),add(v,u);
}
dfs(1,0);
init();
while(m--){
ll x=read(),a=read(),y=read(),b=read();
if(a==0&&b==0&&(gi[0][x]==y||gi[0][y]==x)){
puts("-1");continue;
}
printf("%lld\n",get(x,a,y,b));
}
return 0;
}