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=100010;
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<<2],maxsum[maxn<<2],prefix[maxn<<2],suffix[maxn<<2],lc[maxn<<2],rc[maxn<<2],root[maxn],cnt=0;
int p[maxn],size[maxn],d[maxn],dfn[maxn],finish[maxn],tim=0,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__=128<<20;
    char *__p__=(char*)malloc(__size__)+__size__;
    __asm__("movl %0, %%esp\n"::"r"(__p__));
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%d",&w[i]);
    for(int i=1,x,y;i<n;i++){
        scanf("%d%d",&x,&y);
        G[x].push_back(y);
        G[y].push_back(x);
    }
    dfs1(1);
    dfs2(1);
    while(m--){
        int d;
        scanf("%d",&d);
        if(d==1){
            int x,z;
            scanf("%d%d",&x,&z);
            modify(x,z);
        }
        else printf("%d\n",heap.top());
    }
    return 0;
}
void dfs1(int x){
    size[x]=1;
    d[x]=d[p[x]]+1;
    for(int i=0;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=0;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]]],0);
    }
    finish[x]=tim;
    if(top[x]==x){
        int cnt=0,y=x;
        while(y){
            a[++cnt]=f[y];
            y=son[y];
        }
        len[x]=cnt;
        build(1,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]]+1;
        k=f[x];
        modify(1,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],0);
        return;
    }
    int mid=(l+r)>>1;
    build(l,mid,lc[rt]);
    build(mid+1,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,0);
        return;
    }
    int mid=(l+r)>>1;
    if(t<=mid)modify(l,mid,lc[rt]);
    else modify(mid+1,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]]);
}