【NOIP2018】保卫王国 动态dp

此题场上打了一个正确的$44pts$，接着看错题疯狂$rush$“正确”的$44pts$，后来没$rush$完没将之前的代码$copy$回去，直接变零分了。。。。。

这一题我们显然有一种$O(nm)$的做法

令$f[u][0]$表示在以$u$为根的子树内部署军队，且$u$不部署军队的最小代价。

令$f[u][1]$表示在以$u$为根的子树内部署军队，且$u$部署军队的最小代价。

结合题意（重要！）不难推出：

$f[u][0]=\sum_{v∈son[u]} f[v][1]$

$f[u][1]=val_u+\sum_{v∈son[u]} min(f[v][0],f[v][1])}$

考虑满足能选/不能选的要求，我们只需要临时将被选择点的权值赋值为$INF$或$-INF$即可。

考虑这棵树是一条链的情况：我们用一棵线段树，每个节点维护一个答案矩阵（该区间左端点驻军/可能不驻军，该区间右端点驻军/可能不驻军时的最小代价）。我们求一个节点的答案矩阵，显然可以通过其儿子的答案矩阵，通过大力分类讨论（详见代码）实现更新。

当出现修改权值的情况时，大力改一改然后$pushup$即可。

我们考虑将这一个链上做法扩展到树上。我们用树链剖分将整棵树剖成若干条链，对于轻边上的一对节点$(u,son[u])$，我们将$son[u]$所在链的信息加入节点$u$所对应答案矩阵内即可（详见代码）。

一遍过样例开了$O2$就过了美滋滋

 #include<bits/stdc++.h>
 #define mid ((a[x].l+a[x].r)>>1)
 #define L long long
 #define INF (1LL<<50)
 #define LOW (1LL<<40)
 #define M 100005
 using namespace std;

 struct edge{int u,next;}e[M*]={}; int head[M]={},use=;
 void add(int x,int y){use++;e[use].u=y;e[use].next=head[x];head[x]=use;}

 int siz[M]={},dfn[M]={},rec[M]={},top[M]={},dn[M]={},son[M]={},fa[M]={},t=;

 void dfs(int x){
     siz[x]=;
     for(int i=head[x];i;i=e[i].next) if(e[i].u!=fa[x]){
         fa[e[i].u]=x;
         dfs(e[i].u);
         siz[x]+=siz[e[i].u];
         if(siz[son[x]]<siz[e[i].u]) son[x]=e[i].u;
     }
 }
 void dfs(int x,int Top){
     top[x]=Top; dfn[x]=++t; rec[t]=x;
     if(son[x]) dfs(son[x],Top),dn[x]=dn[son[x]]; else dn[x]=x;
     for(int i=head[x];i;i=e[i].next)
     if(e[i].u!=fa[x]&&e[i].u!=son[x]) dfs(e[i].u,e[i].u);
 }

 L f[M][]={},val[M]={};
 void dp(int x){
     f[x][]=val[x];
     for(int i=head[x];i;i=e[i].next) if(e[i].u!=fa[x]){
         dp(e[i].u);
         f[x][]+=f[e[i].u][];
         f[x][]+=min(f[e[i].u][],f[e[i].u][]);
     }
 }

 struct mat{
     L a[][]; mat(){memset(a,,sizeof(a));}
     mat(L x){a[][]=a[][]=a[][]=a[][]=x;}
     mat(L a1,L a2,L a3,L a4){a[][]=a1; a[][]=a2; a[][]=a3; a[][]=a4;}
     L ans(){ return min(min(a[][],a[][]),min(a[][],a[][]));}
     void upd(L now){a[][]+=now; a[][]+=now; a[][]+=now;}
     friend mat operator *(mat a,mat b){
         mat c=INF;
         for(int i=;i<;i++)
         for(int j=;j<;j++){
             for(int i1=;i1<;i1++)
             for(int j1=;j1<;j1++)
             if(!(i1==&&j1==))
             c.a[i][j]=min(c.a[i][j],a.a[i][i1]+b.a[j1][j]);
         }
         return c;
     }
 }wei[M];
 struct seg{int l,r; mat s;}a[M<<];
 void pushup(int x){a[x].s=a[x<<].s*a[x<<|].s;}

 void build(int x,int l,int r){
     a[x].l=l; a[x].r=r;
     if(l==r){
         int u=rec[l]; L g0=,g1=val[u];
         for(int i=head[u];i;i=e[i].next)
         if(e[i].u!=fa[u]&&e[i].u!=son[u]){
             g0+=f[e[i].u][];
             g1+=min(f[e[i].u][],f[e[i].u][]);
         }
         a[x].s=wei[l]=mat(g1,g1,g1,g0);
         return;
     }
     build(x<<,l,mid); build(x<<|,mid+,r);
     pushup(x);
 }
 mat query(int x,int l,int r){
     if(l<=a[x].l&&a[x].r<=r) return a[x].s;
     if(r<=mid) return query(x<<,l,r);
     if(mid<l) return query(x<<|,l,r);
     return query(x<<,l,r)*query(x<<|,l,r);
 }
 mat query(int x){return query(,dfn[top[x]],dfn[dn[x]]);}
 L solve(){mat hh=query(); return hh.ans();} 

 void updata(int x,int k){
     if(a[x].l==a[x].r) return void(a[x].s=wei[k]);
     if(k<=mid) updata(x<<,k); else updata(x<<|,k);
     pushup(x);
 }
 void Updata(int x,L Val){
     L chg=Val-val[x]; val[x]+=chg;
     wei[dfn[x]].upd(chg);
     while(x){
         mat last=query(x);
         L lg1=last.ans(),lg0=min(last.a[][],last.a[][]);

         updata(,dfn[x]);

         mat now=query(x);
         L ng1=now.ans(),ng0=min(now.a[][],now.a[][]); 

         x=fa[top[x]]; if(!x) return;
         wei[dfn[x]].upd(ng1-lg1);
         wei[dfn[x]].a[][]+=ng0-lg0;
     }
 }

 int n,m; char op[];

 int main(){
     //freopen("defense.in","r",stdin);
     //freopen("defense.out","w",stdout);
     scanf("%d%d%s",&n,&m,op);
     for(int i=;i<=n;i++) scanf("%lld",val+i);
     for(int i=,x,y;i<n;i++) scanf("%d%d",&x,&y),add(x,y),add(y,x);
     dfs();
     dfs(,);
     dp();
     build(,,n);
     //cout<<solve()<<endl;
     while(m--){
         int A,x,B,y; scanf("%d%d%d%d",&A,&x,&B,&y);
         L lastA=val[A],lastB=val[B],chg=;

         if(x==) Updata(A,INF);
         else Updata(A,-INF);

         if(y==) Updata(B,INF);
         else Updata(B,-INF);

         L res=solve();
         if(x) res+=INF+lastA;
         if(y) res+=INF+lastB;

         Updata(A,lastA);
         Updata(B,lastB);

         if(res>LOW){printf("-1\n"); continue;}
         printf("%lld\n",res);
     }
 }