bzoj 4712: 洪水 树链剖分+线段树优化dp

题意

小A走到一个山脚下，准备给自己造一个小屋。这时候，小A的朋友（op，又叫管理员）打开了创造模式，然后飞到山顶放了格水。于是小A面前出现了一个瀑布。作为平民的小A只好老实巴交地爬山堵水。那么问题来了：我们把这个瀑布看成是一个n个节点的树，每个节点有权值（爬上去的代价）。小A要选择一些节点，以其权值和作为代价将这些点删除（堵上），使得根节点与所有叶子结点不连通。问最小代价。不过到这还没结束。小A的朋友觉得这样子太便宜小A了，于是他还会不断地修改地形，使得某个节点的权值发生变化。不过到这还没结束。小A觉得朋友做得太绝了，于是放弃了分离所有叶子节点的方案。取而代之的是，每次他只要在某个子树中（和子树之外的点完全无关）。于是他找到你。
n<=200000，保证任意增加的权值都为非负数。

分析

如果没有修改操作的话，设dp[x]表示以x为根的答案，$h[x]=\sum dp[son]$，显然有dp[x]=min(w[x],h[x])
在$w[x]$增加一个值后，dp[x]肯定不会减少。设dp[x]增加了delta，那么如果x的父亲f满足h[f]+delta不大于w[f]，那么dp[f]就要加上delta。同理可以拓展到f的父亲。
那么我们可以用线段树记录每个点w[x]-h[x]的最小值，然后在线段树上二分找到深度最小的一个点x满足w[x]-h[x]不小于delta，然后将这些点的dp值减去delta即可。
对于x的父亲，它的dp值需要重新计算。而如果它的dp值改变了，我们就重复上述过程即可。
因为每个点的dp值重新计算后其h值就会大于其w值，也就是说重计算最多只有n+m次，所以总复杂度是O((n+m)log^2)。
更具体的细节可以去看Claris的博客。

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;

typedef long long LL;

const int N=200005;
const LL inf=(LL)1<<60;

int n,m,cnt,last[N],fa[N],dep[N],top[N],size[N],dfn[N],tim,bel[N];
LL h[N],dp[N],w[N];
struct edge{int to,next;}e[N*2];
struct tree{LL tag,mn;}t[N*4];

void addedge(int u,int v)
{
    e[++cnt].to=v;e[cnt].next=last[u];last[u]=cnt;
    e[++cnt].to=u;e[cnt].next=last[v];last[v]=cnt;
}

void dfs1(int x)
{
    dep[x]=dep[fa[x]]+1;size[x]=1;
    for (int i=last[x];i;i=e[i].next)
    {
        if (e[i].to==fa[x]) continue;
        fa[e[i].to]=x;
        dfs1(e[i].to);
        size[x]+=size[e[i].to];
        h[x]+=dp[e[i].to];
    }
    if (size[x]==1) h[x]=inf;
    dp[x]=min(w[x],h[x]);
}

void dfs2(int x,int chain)
{
    dfn[x]=++tim;bel[tim]=x;top[x]=chain;int k=0;
    for (int i=last[x];i;i=e[i].next)
        if (e[i].to!=fa[x]&&size[e[i].to]>size[k]) k=e[i].to;
    if (!k) return;
    dfs2(k,chain);
    for (int i=last[x];i;i=e[i].next)
        if (e[i].to!=fa[x]&&e[i].to!=k) dfs2(e[i].to,e[i].to);
}

void pushdown(int d)
{
    if (!t[d].tag) return;
    LL w=t[d].tag;t[d].tag=0;
    t[d*2].tag+=w;t[d*2+1].tag+=w;
    t[d*2].mn-=w;t[d*2+1].mn-=w;
}

void updata(int d)
{
    t[d].mn=min(t[d*2].mn,t[d*2+1].mn);
}

void build(int d,int l,int r)
{
    if (l==r) {int x=bel[l];t[d].tag=h[x];t[d].mn=w[x]-h[x];return;}
    int mid=(l+r)/2;
    build(d*2,l,mid);build(d*2+1,mid+1,r);
    updata(d);
}

LL get_h(int d,int l,int r,int x)
{
    if (l<r) pushdown(d);
    if (l==r) {t[d].mn=w[bel[l]]-t[d].tag;return t[d].tag;}
    int mid=(l+r)/2;LL ans;
    if (x<=mid) ans=get_h(d*2,l,mid,x);
    else ans=get_h(d*2+1,mid+1,r,x);
    updata(d);return ans;
}

int modify(int d,int l,int r,int x,int y,LL delta)
{
    if (l<r) pushdown(d);
    int mid=(l+r)/2,ans;
    if (l==x&&r==y)
    {
        if (t[d].mn>=delta) {t[d].tag+=delta;t[d].mn-=delta;return 0;}
        if (l==r) {t[d].tag+=delta;t[d].mn-=delta;return bel[l];};
        int z=modify(d*2+1,mid+1,r,mid+1,y,delta);
        if (z) {updata(d);return z;}
        ans=modify(d*2,l,mid,x,mid,delta);
        updata(d);return ans;
    }
    if (y<=mid) ans=modify(d*2,l,mid,x,y,delta);
    else if (x>mid) ans=modify(d*2+1,mid+1,r,x,y,delta);
    else
    {
        int z=modify(d*2+1,mid+1,r,mid+1,y,delta);
        if (z) ans=z;
        else ans=modify(d*2,l,mid,x,mid,delta);
    }
    updata(d);
    return ans;
}

void modify(int x,LL delta)
{
    if (delta<=0) return;
    int z=0;
    while (x)
    {
        z=modify(1,1,n,dfn[top[x]],dfn[x],delta);
        if (z) break;
        x=fa[top[x]];
    }
    if (z) modify(fa[z],w[z]-get_h(1,1,n,dfn[z])+delta);
}

int main()
{
    scanf("%d",&n);
    for (int i=1;i<=n;i++) scanf("%lld",&w[i]);
    for (int i=1;i<n;i++)
    {
        int x,y;scanf("%d%d",&x,&y);
        addedge(x,y);
    }
    dfs1(1);dfs2(1,1);
    build(1,1,n);
    scanf("%d",&m);
    while (m--)
    {
        char ch[2];scanf("%s",ch);
        if (ch[0]=='Q')
        {
            int x;scanf("%d",&x);
            printf("%lld\n",min(get_h(1,1,n,dfn[x]),w[x]));
        }
        else
        {
            int x;LL y;scanf("%d%lld",&x,&y);
            w[x]+=y;LL h=get_h(1,1,n,dfn[x]);
            if (w[x]-y<h) modify(fa[x],min(h,w[x])-min(h,w[x]-y));
        }
    }
    return 0;
}