洛谷P4719 【模板】动态dp

https://www.luogu.org/problemnew/show/P4719

大概就是一条链一条链的处理（“链”在这里指重链），对于每一条链，对于其上每一个点，先算出它自身和所有轻儿子的贡献，当做这一步中这个点的“权值”，然后就变成序列上dp，直接用线段树维护

线段树版本O(n*log^2)

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 using namespace std;
 typedef long long ll;
 struct E
 {
     int to,nxt;
 }e[];
 int f1[],ne;
 struct P1
 {
     ll d[][];//左侧不选/选，右侧不选/选
 };
 struct P2
 {
     ll d[];//自身不选/选
 };
 ll a[];
 int sz[],hson[],ff[];
 int b[],pl[];
 int n,m;
 inline ll max1(ll a,ll b)
 {
     return a>b?a:b;
 }
 const ll inf1=-0x3f3f3f3f3f3f3f3f;
 #define max max1
 #define G(x) max1((x),inf1)
 inline void merge(P1 &c,const P1 &a,const P1 &b)
 {
     c.d[][]=G(max(a.d[][]+max(b.d[][],b.d[][]),
         a.d[][]+b.d[][]));
     c.d[][]=G(max(a.d[][]+max(b.d[][],b.d[][]),
         a.d[][]+b.d[][]));
     c.d[][]=G(max(a.d[][]+max(b.d[][],b.d[][]),
         a.d[][]+b.d[][]));
     c.d[][]=G(max(a.d[][]+max(b.d[][],b.d[][]),
         a.d[][]+b.d[][]));
 }
 inline void initnode(P1 &c,const P2 &a)
 {
     c.d[][]=a.d[];c.d[][]=a.d[];
     c.d[][]=c.d[][]=inf1;
 }
 namespace S
 {
 #define lc (num<<1)
 #define rc (num<<1|1)
     P1 d[];
     inline void upd(int num){merge(d[num],d[lc],d[rc]);}
     P1 x;int L;
     void _setx(int l,int r,int num)
     {
         if(l==r)
         {
             d[num]=x;
             return;
         }
         int mid=(l+r)>>;
         if(L<=mid)    _setx(l,mid,lc);
         else    _setx(mid+,r,rc);
         upd(num);
     }
     P1 getx(int L,int R,int l,int r,int num)
     {
         if(L<=l&&r<=R)    return d[num];
         int mid=(l+r)>>;
         if(L<=mid&&mid<R)
         {
             P1 x;
             merge(x,getx(L,R,l,mid,lc),getx(L,R,mid+,r,rc));
             return x;
         }
         else if(L<=mid)
             return getx(L,R,l,mid,lc);
         else if(mid<R)
             return getx(L,R,mid+,r,rc);
         else
             exit(-);
     }
 }
 void dfs1(int u,int fa)
 {
     sz[u]=;
     for(int v,k=f1[u];k;k=e[k].nxt)
         if(e[k].to!=fa)
         {
             v=e[k].to;
             ff[v]=u;
             dfs1(v,u);
             sz[u]+=sz[v];
             if(sz[v]>sz[hson[u]])    hson[u]=v;
         }
 }
 P2 d1[];//d1[i]维护i节点及其轻儿子的贡献
 P2 d2[];//d2[i]维护i节点(是重链顶)所在重链的dp值
 int tp[],dwn[];//链顶,链底
 void dfs2(int u,int fa)
 {
     d1[u].d[]=;d1[u].d[]=a[u];
     b[++b[]]=u;pl[u]=b[];
     tp[u]=(u==hson[fa])?tp[fa]:u;
     if(hson[u])    dfs2(hson[u],u);
     dwn[u]=hson[u]?dwn[hson[u]]:u;
     int v,k;
     for(k=f1[u];k;k=e[k].nxt)
         if(e[k].to!=fa&&e[k].to!=hson[u])
         {
             v=e[k].to;
             dfs2(v,u);
             d1[u].d[]+=max(d2[v].d[],d2[v].d[]);
             d1[u].d[]+=d2[v].d[];
         }
     initnode(S::x,d1[u]);S::L=pl[u];S::_setx(,n,);
     if(u==tp[u])
     {
         P1 t=S::getx(pl[u],pl[dwn[u]],,n,);
         d2[u].d[]=max(t.d[][],t.d[][]);
         d2[u].d[]=max(t.d[][],t.d[][]);
     }
 }
 int main()
 {
     int i,x,y;ll z;P1 t;
     scanf("%d%d",&n,&m);
     for(i=;i<=n;++i)    scanf("%lld",a+i);
     for(i=;i<n;++i)
     {
         scanf("%d%d",&x,&y);
         e[++ne].to=y;e[ne].nxt=f1[x];f1[x]=ne;
         e[++ne].to=x;e[ne].nxt=f1[y];f1[y]=ne;
     }
     dfs1(,);
     dfs2(,);
     while(m--)
     {
         scanf("%d%lld",&x,&z);
         d1[x].d[]-=a[x];a[x]=z;d1[x].d[]+=z;
         while(x)
         {
             initnode(S::x,d1[x]);S::L=pl[x];S::_setx(,n,);
             x=tp[x];y=ff[x];
             t=S::getx(pl[x],pl[dwn[x]],,n,);
             d1[y].d[]-=max(d2[x].d[],d2[x].d[]);
             d1[y].d[]-=d2[x].d[];
             d2[x].d[]=max(t.d[][],t.d[][]);
             d2[x].d[]=max(t.d[][],t.d[][]);
             d1[y].d[]+=max(d2[x].d[],d2[x].d[]);
             d1[y].d[]+=d2[x].d[];
             x=y;
         }
         //printf("%lld %lld\n",d2[1].d[0],d2[1].d[1]);
         printf("%lld\n",max(d2[].d[],d2[].d[]));
     }
     return ;
 }

bst版本O(n*log)

待写