【洛谷P4719】动态dp 动态dp模板

题目大意：给你一颗$n$个点的树，点有点权，有$m$次操作，每次操作给定$x$,$y$，表示修改点$x$的权值为$y$。

你需要在每次操作之后求出这棵树的最大权独立集的权值大小。

数据范围：$n,m≤1e5$

我们显然可以得出一个$O(nm)$的暴力做法，每次修改完后$dp$一次，然而这个显然会超时。

考虑当树退化成链时的简单做法。

我们用线段树维护每个区间的答案。对于区间$[l,r]$，我们维护一个$2×2$的答案矩阵$ans$。

设$ans[0][0]$表示区间左端点可能被选择，右端点一定不被选择时的最大值。

设$ans[0][1]$表示区间左端点可能被选择，右端点可能被选择时的最大值。

设$ans[1][0]$表示区间左端点一定不被选择，右端点一定不被选择时的最大值。

设$ans[1][1]$表示区间左端点一定不被选择，右端点可能被选择时的最大值。

对于叶节点，显然$ans[0][0]=ans[0][1]=0$，$ans[1][0]=val[x]$，$ans[1][1]=-INF$。

考虑已经求出$[l,mid]$，$[mid+1,r]$两个区间的答案，如何合并出$[l,r]$的答案。

不难发现$ans[0][0]=max(ansl[0][0]+ansr[0][0],ansl[0][1]+ansr[1][0])$;

$ans[0][1],ans[1][0],ans[1][1]$的转移都长得差不多。

每次修改一个权值，我们可以通过$pushup$更新区间的答案矩阵。

考虑把这个做法扩展到树上，我们通过树链剖分将整棵树剖成若干条链，对于每一条链我们就用如上所述的方式进行维护。对于接有轻儿子的链上节点，我们将轻儿子产生的共吸纳累计，将其加到链上节点上即可。

（细节可以看代码）

时间复杂度：$O(m log^2n)$。

 #include<bits/stdc++.h>
 #define ls (x<<1)
 #define rs (x<<1|1)
 #define mid ((a[x].l+a[x].r)>>1)
 #define L long long
 #define INF 1000000007
 #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 val[M]={},n,m,f[M][]={};

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

 void dfs1(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;
         dfs1(e[i].u);
         siz[x]+=siz[e[i].u];
         if(siz[son[x]]<siz[e[i].u]) son[x]=e[i].u;
     }
 }
 void dfs2(int x,int Top){
     top[x]=Top; dfn[x]=++t; rec[t]=x;
     if(son[x]) dfs2(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])
     dfs2(e[i].u,e[i].u);
 }
 void dp(int x,int fa){
     f[x][]=val[x];
     for(int i=head[x];i;i=e[i].next) if(e[i].u!=fa){
         dp(e[i].u,x);
         f[x][]+=max(f[e[i].u][],f[e[i].u][]);
         f[x][]+=f[e[i].u][];
     }
 }

 struct mat{
     int a[][]; mat(){memset(a,,sizeof(a));}
     mat(int x){a[][]=a[][]=a[][]=a[][]=x;}
     mat(int a1,int a2,int a3,int a4){a[][]=a1; a[][]=a2; a[][]=a3; a[][]=a4;}
     friend mat operator *(mat a,mat b){
         mat c=-INF;
         for(int i=;i<;i++)
         for(int j=;j<;j++)
         for(int k=;k<;k++)
         c.a[i][j]=max(c.a[i][j],a.a[i][k]+b.a[k][j]);
         return c;
     }
 }wei[M];
 struct seg{int l,r;mat a;}a[M<<];
 void pushup(int x){a[x].a=a[ls].a*a[rs].a;}

 void build(int x,int l,int r){
     a[x].l=l; a[x].r=r;
     if(l==r){
         int u=rec[l],g0=,g1=val[u];
         for(int i=head[u];i;i=e[i].next)
         if(e[i].u!=son[u]&&e[i].u!=fa[u]){
             g0+=max(f[e[i].u][],f[e[i].u][]);
             g1+=f[e[i].u][];
         }
         a[x].a=wei[l]=mat(g0,g0,g1,-INF);
         return;
     }
     build(ls,l,mid);
     build(rs,mid+,r);
     pushup(x);
 }
 void updata(int x,int k){
     if(a[x].l==a[x].r) return void(a[x].a=wei[k]);
     if(k<=mid) updata(ls,k);
     else updata(rs,k);
     pushup(x);
 }

 mat query(int x,int l,int r){
     if(l<=a[x].l&&a[x].r<=r) return a[x].a;
     mat res;
     if(l<=mid) res=query(ls,l,r);
     if(mid<r){
         if(l<=mid) return res*query(rs,l,r);
         return query(rs,l,r);
     }else return res;
 }
 mat query(int x){return query(,dfn[top[x]],dfn[dn[x]]);}
 void solve(){mat hh=query(); printf("%d\n",max(hh.a[][],hh.a[][]));}

 void Updata(int x,int Val){
     wei[dfn[x]].a[][]+=Val-val[x]; val[x]=Val;
     while(x){

         mat last=query(x);
         int lg0=max(last.a[][],last.a[][]),lg1=last.a[][];

         updata(,dfn[x]);

         mat now=query(x);
         int ng0=max(now.a[][],now.a[][]),ng1=now.a[][];

         x=fa[top[x]]; if(!x) return;

         int g0=ng0-lg0,g1=ng1-lg1;
         wei[dfn[x]].a[][]+=g0;
         wei[dfn[x]].a[][]+=g0;
         wei[dfn[x]].a[][]+=g1;
     }
 }

 int main(){
     //freopen("in.txt","r",stdin);
     scanf("%d%d",&n,&m);
     for(int i=;i<=n;i++) scanf("%d",val+i);
     for(int i=,x,y;i<n;i++) scanf("%d%d",&x,&y),add(x,y),add(y,x);
     dfs1();
     dfs2(,);
     dp(,);
     build(,,n);
     //solve();
     while(m--){
         int x,y; scanf("%d%d",&x,&y);
         Updata(x,y);
         solve();
     }
 }