bzoj4712 洪水（树形动态dp，树链剖分+线段树二分/链分治）

最新推荐文章于 2019-05-07 09:18:49 发布

Icefox_zhx

最新推荐文章于 2019-05-07 09:18:49 发布

阅读量308

点赞数

分类专栏： bzoj -------数据结构------- 线段树树链剖分 ---------dp----------- 树形dp 二分

本文链接：https://blog.csdn.net/Icefox_zhx/article/details/80721660

版权

bzoj 同时被 3 个专栏收录

764 篇文章 1 订阅

订阅专栏

---------dp-----------

304 篇文章 2 订阅

订阅专栏

-------数据结构-------

251 篇文章 0 订阅

订阅专栏

首先考虑不带修改的话，f[x]表示切断x与子树内的叶子的最小花费，有
$f[x]=min(v[x],s[x]),s[x]=\sum\limits_{y\in son[x]}f[y]$
考虑把点x的权值增加val的影响，首先v[x]+=val,f[x]可能会变大/不变。
如果f[x]不变的话，那么就没有其他影响了，结束。
否则记f[x]的增量为del，对于fa[x]到根的路径上的一段点的s[i]都会增加del。
直到什么时候呢？直到出现 $v[i]-s[i]<del$ ，此时有两种情况：
1、 $v[i]<=s[i]$ ，原来f[i]就是v[i],现在增大了s[i]，并不会改变f[i],因此对上面的点不再有影响，结束。
2、 $v[i]>s[i]$ ，原来 $f[i]=s[i]$ ,
现在 $f[i]=v[i](因为s[i]+del>v[i])$ ，所以再往上的点的s增量变成了v[i]-s[i]。
重复执行此操作直到增量为0或过了根。
好的现在我们就需要快速求出x到根的路径上的第一个 $v[i]-s[i]<del$ 的点和支持路径加操作。我们可以用树链剖分，在线段树上维护区间v[i]-s[i]的最小值，每次在线段树上爬即可。线段树也可以很好的支持区间加操作

考虑一个点要重新计算DP值，当且仅当 $s[x]<v[x]$ ，并且一旦 $s[x]>v[x]$ ，在下次修改这个点的v[x]之前DP值将一直是v[x]。

因此每个点一开始会贡献一个可能的重新计算次数，每次修改也会最多贡献一个，所以总的复杂度就是 $O((n+m)log^2n)$ 。

于是我们就做完了。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define inf 0x3f3f3f3f
#define N 200010
inline char gc(){
    static char buf[1<<16],*S,*T;
    if(S==T){T=(S=buf)+fread(buf,1,1<<16,stdin);if(T==S) return EOF;}
    return *S++;
}
inline int read(){
    int x=0,f=1;char ch=gc();
    while(ch<'0'||ch>'9'){if(ch=='-') f=-1;ch=gc();}
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=gc();
    return x*f;
}
inline char get_S(){
    char ch=gc();while(ch!='C'&&ch!='Q') ch=gc();return ch;
}
int n,m,h[N],num=0,dfn[N],dfnum=0,son[N],sz[N],tp[N],fa[N],dep[N],tid[N];
ll v[N],s[N],f[N];
struct edge{
    int to,next;
}data[N<<1];
struct node{
    ll mn,tag;
}tr[N<<2];
inline void dfs1(int x){
    sz[x]=1;son[x]=0;s[x]=0;
    for(int i=h[x];i;i=data[i].next){
        int y=data[i].to;if(y==fa[x]) continue;
        fa[y]=x;dep[y]=dep[x]+1;dfs1(y);sz[x]+=sz[y];
        if(sz[y]>sz[son[x]]) son[x]=y;s[x]+=f[y];
    }if(sz[x]==1) s[x]=inf;f[x]=min(v[x],s[x]);
}
inline void dfs2(int x,int top){
    tp[x]=top;dfn[x]=++dfnum;tid[dfnum]=x;
    if(son[x]) dfs2(son[x],top);
    for(int i=h[x];i;i=data[i].next){
        int y=data[i].to;if(y!=son[x]&&y!=fa[x]) dfs2(y,y);
    }
}
inline void pushup(int p){
    tr[p].mn=min(tr[p<<1].mn,tr[p<<1|1].mn);
}
inline void doadd(int p,ll val){
    tr[p].tag+=val;tr[p].mn+=val;
}
inline void pushdown(int p){
    if(!tr[p].tag) return;
    doadd(p<<1,tr[p].tag);doadd(p<<1|1,tr[p].tag);tr[p].tag=0;
}
inline void build(int p,int l,int r){
    if(l==r){tr[p].mn=v[tid[l]]-s[tid[l]];return;}
    int mid=l+r>>1;build(p<<1,l,mid);build(p<<1|1,mid+1,r);pushup(p);
}
inline ll ask(int p,int l,int r,int x){
    if(l==r) return tr[p].mn;
    int mid=l+r>>1;pushdown(p);
    if(x<=mid) return ask(p<<1,l,mid,x);
    return ask(p<<1|1,mid+1,r,x);
}
inline void add(int p,int l,int r,int x,ll val){
    if(l==r){tr[p].mn+=val;return;}
    int mid=l+r>>1;pushdown(p);
    if(x<=mid) add(p<<1,l,mid,x,val);
    else add(p<<1|1,mid+1,r,x,val);pushup(p);
}
inline int change(int p,int l,int r,int x,int y,ll val){
    if(x==l&&r==y){
        if(tr[p].mn>=val){doadd(p,-val);return 0;}
        if(l==r){doadd(p,-val);return tid[l];}
        int mid=l+r>>1;pushdown(p);
        int res=change(p<<1|1,mid+1,r,mid+1,y,val);
        if(!res) res=change(p<<1,l,mid,x,mid,val);pushup(p);return res;
    }int mid=l+r>>1;pushdown(p);
    if(y<=mid){
        int res=change(p<<1,l,mid,x,y,val);pushup(p);return res;
    }if(x>mid){
        int res=change(p<<1|1,mid+1,r,x,y,val);pushup(p);return res;
    }int res=change(p<<1|1,mid+1,r,mid+1,y,val);
    if(!res) res=change(p<<1,l,mid,x,mid,val);pushup(p);return res;
}
inline ll cals(int x){
    return v[x]-ask(1,1,n,dfn[x]);
}
inline void gao(int x,ll val){
    if(!x||!val) return;
    int y=change(1,1,n,dfn[tp[x]],dfn[x],val);
    if(!y){gao(fa[tp[x]],val);return;}
    ll sy=cals(y)-val;if(v[y]<=sy) return;
    gao(fa[y],v[y]-sy);
}
int main(){
//  freopen("a.in","r",stdin);
    n=read();
    for(int i=1;i<=n;++i) v[i]=read();
    for(int i=1;i<n;++i){
        int x=read(),y=read();
        data[++num].to=y;data[num].next=h[x];h[x]=num;
        data[++num].to=x;data[num].next=h[y];h[y]=num;
    }dfs1(1);dfs2(1,1);build(1,1,n);m=read();
    while(m--){
        char op=get_S();int x=read();
        if(op=='Q'){printf("%lld\n",min(cals(x),v[x]));continue;}
        ll y=read(),sx=cals(x);
        add(1,1,n,dfn[x],y);v[x]+=y;
        if(v[x]-y>=sx) continue;
        gao(fa[x],min(sx,v[x])-(v[x]-y));
    }return 0;
}

immortalCO在他的论文中加强了此题，n<=1e6，把增加一个点的权值变成了改变一个点的权值。
这样就没有了点权不降的性质，上面那种基于决策点变动的均摊算法也就无法再适用了。
不过我们有更优秀的做法！记这回的s[x]表示所有轻儿子y的f[y]之和。我们考虑一条重链，把点从链顶向链底标号，那么
$f[x]=min(v[x],s[x]+f[x+1])$ ，特殊的对于链底m, $f[m]=min(v[m],s[m])$
我们可以把这个转移写成矩阵的形式：

(s [i] - i n f a [i] 0) \times (f [i + 1] 0) = (f [i] 0)

$\begin{pmatrix} s[i] & a[i]\\\ -inf & 0 \end{pmatrix}\times\begin{pmatrix} f[i+1]\\\ 0 \end{pmatrix}=\begin{pmatrix} f[i]\\\ 0 \end{pmatrix}$
重定义加法为取min，乘法为加。
这样就可以线段树分治，每个点一个转移矩阵即可。
每次修改点x首先修改x的矩阵，然后算出新的f[tp[x]]与原来的差值，用来更新fa[tp[x]]的s。一直更新到跟即可。
询问f[x]的时候，我们直接用(0,0)左乘x所在重链的后缀矩阵乘积即可。
这样对每条重链建一棵线段树比较方便x
初始化

O(n) O ( n ) $O(n)$ ，修改

O(log2n) O ( l o g 2 n ) $O(log^2n)$ ，查询

O(logn) O ( l o g n ) $O(logn)$
不过写成矩阵这样来合并的话，估计常数巨大。可以发现矩阵第二行基本没啥用，直接维护第一行的两个数即可。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define inf 0x3f3f3f3f
#define N 200010
inline char gc(){
    static char buf[1<<16],*S,*T;
    if(S==T){T=(S=buf)+fread(buf,1,1<<16,stdin);if(T==S) return EOF;}
    return *S++;
}
inline int read(){
    int x=0,f=1;char ch=gc();
    while(ch<'0'||ch>'9'){if(ch=='-') f=-1;ch=gc();}
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=gc();
    return x*f;
}
inline char get_S(){
    char ch=gc();while(ch!='C'&&ch!='Q') ch=gc();return ch;
}
int n,m,h[N],num=0,son[N],sz[N],tp[N],fa[N],dep[N],tid[N],a[N],rt[N],bot[N],owo=0;
ll v[N],s[N],f[N];
stack<int>qq;
struct edge{
    int to,next;
}data[N<<1];
struct node{
    ll a,b;int ls,rs;
    inline ll calc(){return min(a,b);}
    friend node operator+(const node &a,const node &b){
        node res;res.b=a.b+b.b;res.a=min(a.a,a.b+b.a);return res;
    }
}tr[N<<1];
inline void pushup(int p){
    tr[p].b=tr[tr[p].ls].b+tr[tr[p].rs].b;
    tr[p].a=min(tr[tr[p].ls].a,tr[tr[p].ls].b+tr[tr[p].rs].a);
}
inline void build(int &p,int l,int r){
    p=++owo;if(l==r){tr[p].a=v[a[l]];tr[p].b=s[a[l]];return;}
    int mid=l+r>>1;build(tr[p].ls,l,mid);build(tr[p].rs,mid+1,r);pushup(p);
}
inline void solve(int x){//对每条链建一棵线段树，常数优化qaq
    int tot=0;
    while(1){
        int y=qq.top();qq.pop();a[++tot]=y;
        if(y==x) break;
    }for(int i=1,j=tot;i<j;++i,--j) swap(a[i],a[j]);
    build(rt[x],1,tot);for(int i=1;i<=tot;++i) tid[a[i]]=i;
}
inline void dfs1(int x){
    sz[x]=1;son[x]=0;
    for(int i=h[x];i;i=data[i].next){
        int y=data[i].to;if(y==fa[x]) continue;
        fa[y]=x;dep[y]=dep[x]+1;dfs1(y);sz[x]+=sz[y];
        if(sz[y]>sz[son[x]]) son[x]=y;
    }
}
inline void dfs2(int x,int top){
    tp[x]=top;s[x]=0;qq.push(x);
    if(son[x]) dfs2(son[x],top);else bot[top]=x;
    for(int i=h[x];i;i=data[i].next){
        int y=data[i].to;if(y==son[x]||y==fa[x]) continue;
        dfs2(y,y),s[x]+=f[y];solve(y);
    }if(sz[x]==1) s[x]=inf;f[x]=min(v[x],s[x]+f[son[x]]);
}
inline node ask(int p,int l,int r,int x,int y){
    if(x<=l&&r<=y) return tr[p];
    int mid=l+r>>1;
    if(y<=mid) return ask(tr[p].ls,l,mid,x,y);
    if(x>mid) return ask(tr[p].rs,mid+1,r,x,y);
    return ask(tr[p].ls,l,mid,x,mid)+ask(tr[p].rs,mid+1,r,mid+1,y);
}
inline void adda(int p,int l,int r,int x,ll val){
    if(l==r){tr[p].a+=val;return;}
    int mid=l+r>>1;
    if(x<=mid) adda(tr[p].ls,l,mid,x,val);
    else adda(tr[p].rs,mid+1,r,x,val);pushup(p);
}
inline void addb(int p,int l,int r,int x,ll val){
    if(l==r){tr[p].b+=val;return;}
    int mid=l+r>>1;
    if(x<=mid) addb(tr[p].ls,l,mid,x,val);
    else addb(tr[p].rs,mid+1,r,x,val);pushup(p);
}
inline void gao(int x,ll val){
    if(!val||!x) return;
    ll tmp=tr[rt[tp[x]]].calc();
    addb(rt[tp[x]],1,tid[bot[tp[x]]],tid[x],val);
    gao(fa[tp[x]],tr[rt[tp[x]]].calc()-tmp);
}
int main(){
//  freopen("a.in","r",stdin);
    n=read();
    for(int i=1;i<=n;++i) v[i]=read();
    for(int i=1;i<n;++i){
        int x=read(),y=read();
        data[++num].to=y;data[num].next=h[x];h[x]=num;
        data[++num].to=x;data[num].next=h[y];h[y]=num;
    }dfs1(1);dfs2(1,1);solve(1);m=read();
    while(m--){
        char op=get_S();int x=read();
        if(op=='Q'){printf("%lld\n",ask(rt[tp[x]],1,tid[bot[tp[x]]],tid[x],tid[bot[tp[x]]]).calc());continue;}
        ll y=read(),tmp=tr[rt[tp[x]]].calc();adda(rt[tp[x]],1,tid[bot[tp[x]]],tid[x],y);
        gao(fa[tp[x]],tr[rt[tp[x]]].calc()-tmp);
    }return 0;
}

Icefox_zhx

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
bzoj4712 洪水（树形动态dp，树链剖分+线段树二分/链分治）

首先考虑不带修改的话，f[x]表示切断x与子树内的叶子的最小花费，有 f[x]=min(v[x],s[x]),s[x]=∑y∈son[x]f[y]f[x]=min(v[x],s[x]),s[x]=∑y∈son[x]f[y]f[x]=min(v[x],s[x]),s[x]=\sum\limits_{y\in son[x]}f[y] 考虑把点x的权值增加val的影响，首先v[x]+=val,f[x...
复制链接

扫一扫