COGS2608 [河南省队2016]无根树

传送门

这题大概就是传说中的动态树形DP了吧，学习了一波……

首先，对于没有修改的情况，不难想到树形DP，定义$f_i$表示强制必须选$i$且只能再选$i$的子树中的点的最优解，易得转移方程$f_i=\sum_{j是i的儿子}\max\{f_j,0\}+w_i$，最终答案即为$\max\{f_i\}$。

现在我们不仅需要求出答案，还要在每次修改之后快速计算新的答案。借鉴陈俊锟的论文，可以用树剖来做这道题，那么我们只需要对每条链动态维护答案即可，最后用一个全局堆维护每条链的答案就可以了。

我们可以重新定义$f_i$表示只考虑$i$以及轻边连出去的子树的最优解，并用线段树维护重链，不难看出每条链的答案就是链上所有点的$f$值的最大子段和。那么直接用线段树维护最大子段和即可，预处理$O(n)$，单次修改$O(\log^2 n)$，查询$O(1)$。

细节不是很多，当然愿意看代码也行。

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<vector>
 #include<queue>
 using namespace std;
 const int maxn=;
 struct binary_heap{
     priority_queue<int>q1,q2;
     binary_heap(){}
     void push(int x){q1.push(x);}
     void erase(int x){q2.push(x);}
     int top(){
         while(!q2.empty()&&q1.top()==q2.top()){
             q1.pop();
             q2.pop();
         }
         return q1.top();
     }
 }heap;
 void dfs1(int);
 void dfs2(int);
 void modify(int,int);
 void build(int,int,int&);
 void modify(int,int,int);
 void refresh(int);
 vector<int>G[maxn];
 int sum[maxn<<],maxsum[maxn<<],prefix[maxn<<],suffix[maxn<<],lc[maxn<<],rc[maxn<<],root[maxn],cnt=;
 int p[maxn],size[maxn],d[maxn],dfn[maxn],finish[maxn],tim=,son[maxn],top[maxn],len[maxn];
 int f[maxn],a[maxn],w[maxn];
 int n,m,t,k;
 int main(){
     freopen("nortree.in","r",stdin);
     freopen("nortree.out","w",stdout);
     int __size__=<<;
     char *__p__=(char*)malloc(__size__)+__size__;
     __asm__("movl %0, %%esp\n"::"r"(__p__));
     scanf("%d%d",&n,&m);
     for(int i=;i<=n;i++)scanf("%d",&w[i]);
     for(int i=,x,y;i<n;i++){
         scanf("%d%d",&x,&y);
         G[x].push_back(y);
         G[y].push_back(x);
     }
     dfs1();
     dfs2();
     while(m--){
         int d;
         scanf("%d",&d);
         if(d==){
             int x,z;
             scanf("%d%d",&x,&z);
             modify(x,z);
         }
         else printf("%d\n",heap.top());
     }
     return ;
 }
 void dfs1(int x){
     size[x]=;
     d[x]=d[p[x]]+;
     for(int i=;i<(int)G[x].size();i++)if(G[x][i]!=p[x]){
         p[G[x][i]]=x;
         dfs1(G[x][i]);
         size[x]+=size[G[x][i]];
         if(size[G[x][i]]>size[son[x]])son[x]=G[x][i];
     }
 }
 void dfs2(int x){
     if(x==son[p[x]])top[x]=top[p[x]];
     else top[x]=x;
     dfn[x]=++tim;
     f[x]=w[x];
     if(son[x])dfs2(son[x]);
     for(int i=;i<(int)G[x].size();i++)if(G[x][i]!=p[x]&&G[x][i]!=son[x]){
         dfs2(G[x][i]);
         f[x]+=max(prefix[root[G[x][i]]],);
     }
     finish[x]=tim;
     if(top[x]==x){
         int cnt=,y=x;
         while(y){
             a[++cnt]=f[y];
             y=son[y];
         }
         len[x]=cnt;
         build(,len[x],root[x]);
         heap.push(maxsum[root[x]]);
     }
 }
 void modify(int x,int z){
     f[x]+=z-w[x];
     w[x]=z;
     while(x){
         if(p[top[x]])f[p[top[x]]]-=prefix[root[top[x]]];
         heap.erase(maxsum[root[top[x]]]);
         t=d[x]-d[top[x]]+;
         k=f[x];
         modify(,len[top[x]],root[top[x]]);
         if(p[top[x]])f[p[top[x]]]+=prefix[root[top[x]]];
         heap.push(maxsum[root[top[x]]]);
         x=p[top[x]];
     }
 }
 void build(int l,int r,int &rt){
     rt=++cnt;
     if(l==r){
         sum[rt]=a[l];
         maxsum[rt]=prefix[rt]=suffix[rt]=max(a[l],);
         return;
     }
     int mid=(l+r)>>;
     build(l,mid,lc[rt]);
     build(mid+,r,rc[rt]);
     refresh(rt);
 }
 void modify(int l,int r,int rt){
     if(l==r){
         sum[rt]=k;
         maxsum[rt]=prefix[rt]=suffix[rt]=max(k,);
         return;
     }
     int mid=(l+r)>>;
     if(t<=mid)modify(l,mid,lc[rt]);
     else modify(mid+,r,rc[rt]);
     refresh(rt);
 }
 void refresh(int rt){
     sum[rt]=sum[lc[rt]]+sum[rc[rt]];
     maxsum[rt]=max(max(maxsum[lc[rt]],maxsum[rc[rt]]),suffix[lc[rt]]+prefix[rc[rt]]);
     prefix[rt]=max(prefix[lc[rt]],sum[lc[rt]]+prefix[rc[rt]]);
     suffix[rt]=max(suffix[rc[rt]],sum[rc[rt]]+suffix[lc[rt]]);
 }