[BZOJ4712]洪水-树链剖分-动态规划-线段树

洪水

Description

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

Input

输入文件第一行包含一个数n，表示树的大小。

接下来一行包含n个数，表示第i个点的权值。
接下来n-1行每行包含两个数fr，to。表示书中有一条边（fr，to）。
接下来一行一个整数，表示操作的个数。
接下来m行每行表示一个操作，若该行第一个数为Q，则表示询问操作，后面跟一个参数x，表示对应子树的根；若为C，则表示修改操作，后面接两个参数x，to，表示将点x的权值加上to。
n<=200000，保证任意to都为非负数

Output

对于每次询问操作，输出对应的答案，答案之间用换行隔开。

Sample Input

4
4 3 2 1
1 2
1 3
4 2
4
Q 1
Q 2
C 4 10
Q 1

Sample Output

3
1
4

---

神题……
动态维护dp答案的巧妙方法……
听说可以用一个叫链分治的东西然而没学过……

---

思路:
如果不带修改这就是个普及组dp.jpg

考虑dp式子如下:
令$f[i]$为封堵以$i$为根的子树所需的代价，$g[i]$为$i$所有子节点的$f$之和，$w[i]$为点权:
$f[i]=min(w[i],g[i])$

考虑一个$w$被修改后会发生什么。
令被修改的节点为$x$，修改后的值为$w[x]+v$:

若$w[x]>=g[x]$，则从一开始$f[x]$就等于$g[x]$，因此什么都不会发生。
若$w[x]<g[x]$且$w[x]+v>g[x]$，则$f[x]$的值从$w[x]$变为$g[x]$，$f[x]+=g[x]-w[x]$
若$w[x]+v<=g[x]$，则$f[x]$还是等于$w[x]$，$f[x]+=v$

然后考虑$f[x]$被修改后发生的变化，令$f[x]$增加的值为$v$。
此时$g[fa[x]]$变成了$g[fa[x]]+v$。
若$w[fa[x]]<=g[fa[x]]$，那么显然什么都不会发生，返回。
若$w[fa[x]]>g[fa[x]]$且$w[fa[x]]<g[fa[x]]+v$，那么$f[fa[x]]$的值从$g[fa[x]]$变为$w[fa[x]]$，$f[fa[x]]+=w[fa[x]]-g[fa[x]]$
若$w[fa[x]]>=g[fa[x]]+v$，那么$f[fa[x]]$还是等于$g[fa[x]]$，$f[fa[x]]+=v$

然后若$f[fa[x]]$被修改，则递归调用，一直进行即可~

然而这是暴力。
可以发现，无论修改值怎么变，每次递归时$f$的修改值是单调不增的。
那么考虑树链剖分。
由于$w[x]$可以$O(1)$修改，所以线段树上维护$w[x]-g[x]$。
每次在一根重链上找到一段用当前值修改的前提下合法的一段，并进行修改。
如果是整条链均合法，则跳到链顶的父亲。
否则找到不合法位置，查询不合法位置的信息来计算新的修改值，并递归调用。

可以发现修改是$O(log_2^2)$的。
于是就可以过了~

(借鉴了dalao程序因为实在是调不出来QAQ)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>

using namespace std;

#define mid ((l+r)>>1)
typedef long long ll;
const int N=200009;

int n;
int to[N<<1],nxt[N<<1],beg[N],tot;
int fa[N],siz[N],son[N],top[N],id[N],ed[N],seg[N],dfn;
ll g[N],f[N],w[N],t[N<<2],tag[N<<2];

inline ll read()
{
    ll x=0;char ch=getchar();
    while(ch<'0' || '9'<ch)ch=getchar();
    while('0'<=ch && ch<='9')x=x*10+(ch^48),ch=getchar();
    return x;
}

inline void chkmin(ll &a,ll b){if(a>b)a=b;}
inline ll minn(ll a,ll b){if(a<b)return a;return b;}

inline void add(int u,int v)
{
    to[++tot]=v;
    nxt[tot]=beg[u];
    beg[u]=tot;
}

inline void dfs(int u)
{
    f[u]=w[u];
    siz[u]=1;son[u]=0;
    for(int i=beg[u],v;i;i=nxt[i])
        if((v=to[i])!=fa[u])
        {
            fa[v]=u;
            dfs(v);
            siz[u]+=siz[v];
            g[u]+=f[v];
            if(!son[u] || siz[son[u]]<siz[v])
                son[u]=v;
        }
    if(son[u])
        chkmin(f[u],g[u]);
    else
        g[u]=1e9+7;
}

inline void dfs2(int u)
{
    id[seg[++dfn]=u]=dfn;
    if(son[u])
    {
        top[son[u]]=top[u];
        dfs2(son[u]);
        for(int i=beg[u],v;i;i=nxt[i])
            if((v=to[i])!=fa[u] && v!=son[u])
                dfs2(top[v]=v);
    }
    ed[u]=dfn;
}

inline void update(int x)
{
    t[x]=minn(t[x<<1],t[x<<1|1]);
}

inline void push(int x)
{
    if(tag[x])
    {
        tag[x<<1]+=tag[x];
        tag[x<<1|1]+=tag[x];
        t[x<<1]-=tag[x];
        t[x<<1|1]-=tag[x];
        tag[x]=0;
    }
}

inline void build(int x,int l,int r)
{
    if(l==r)
    {
        t[x]=w[seg[l]]-g[seg[l]];
        return;
    }
    build(x<<1,l,mid);
    build(x<<1|1,mid+1,r);
    update(x);
}

inline int modify(int x,int l,int r,int dl,int dr,ll v)
{
    if(l==r)
    {
        t[x]-=v;
        tag[x]+=v;
        if(t[x]+v<=v)
            return seg[l];
        else
            return 0;
    }

    if(dl==l && r==dr)
    {
        if(t[x]>v)
        {
            t[x]-=v;
            tag[x]+=v;
            return 0;
        }
    }

    push(x);
    int ret=0;
    if(dr<=mid)
        ret=modify(x<<1,l,mid,dl,dr,v);
    else if(mid<dl)
        ret=modify(x<<1|1,mid+1,r,dl,dr,v);
    else
    {
        ret=modify(x<<1|1,mid+1,r,mid+1,dr,v);
        if(!ret)
            ret=modify(x<<1,l,mid,dl,mid,v);
    }
    update(x);
    return ret;
}

inline ll query(int x,int l,int r,int p)
{
    if(l==r)
        return t[x];
    push(x);
    if(p<=mid)
        return query(x<<1,l,mid,p);
    else
        return query(x<<1|1,mid+1,r,p);
}

inline void change(int x,ll v)
{
    if(!x || v<=0)return;
    while(x)
    {
        int p=modify(1,1,n,id[top[x]],id[x],v);
        if(!p)
            x=fa[top[x]];
        else
        {
            change(fa[p],query(1,1,n,id[p])+v);
            return;
        }
    }
}

inline ll gs(int x){return w[x]-query(1,1,n,id[x]);}
#define g(x) gs(x)

int main()
{
    n=read();
    for(int i=1;i<=n;i++)
        w[i]=read();
    for(int i=1,u,v;i<n;i++)
    {
        u=read();v=read();
        add(u,v);add(v,u);
    }

    dfs(1);
    dfs2(top[1]=1);
    build(1,1,n);

    int q=read();
    ll a,b;
    char s[5];
    while(q--)
    {
        scanf("%s",s+1);
        if(s[1]=='Q')
        {
            a=read();
            printf("%lld\n",minn(w[a],g(a)));
        }
        else
        {
            a=read();b=read();
            if(!b)continue;
            w[a]+=b;
            modify(1,1,n,id[a],id[a],-b);
            change(fa[a],minn(w[a],g(a))-w[a]+b);
        }
    }

    return 0;
}