BZOJ 4712: 洪水 树链剖分优化dp

4712: 洪水

Time Limit: 15 Sec  Memory Limit: 256 MB
Submit: 256  Solved: 87

[Submit][Status][Discuss]

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呢~

诶~好像不会这个知识点呢。。。

诶~写写写好像吐了呢 看题解吧。。。

具体的题解看这个：膜力传送门

就是 v s 来回搞搞搞可能哪里搞混或搞挂 不太好调试

#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<string>
#include<bitset>
#include<queue>
#include<set>
#include<map>
using namespace std;

typedef double db;
typedef long long ll;

inline ll read()
{
ll x=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch<='9'&&ch>='0'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
void print(ll x)
{if(x<0)putchar('-'),x=-x;if(x>=10)print(x/10);putchar(x%10+'0');}

const int N=200100,inf=0X3f3f3f3f;

int last
,ecnt;
struct EDGE{int to,nt;}e[N<<1];
inline void add(int u,int v)
{e[++ecnt]=(EDGE){v,last[u]};last[u]=ecnt;}

int n;
ll V
,S
,F
;

int fa
,son
,size
;

void dp(int u)
{
size[u]=1;
for(int i=last[u],v;i;i=e[i].nt)
if(fa[u]!=(v=e[i].to))
{
fa[v]=u;
dp(v);
S[u]+=F[v];
size[u]+=size[v];
if(size[v]>size[son[u]]) son[u]=v;
}
!e[last[u]].nt ? F[u]=V[u],S[u]=inf : F[u]=min(V[u],S[u]);
}

int dfn
,pos
,tim,top
;

void dfs(int u,int tp)
{
dfn[u]=++tim;
pos[tim]=u;
top[u]=tp;
if(son[u]) dfs(son[u],tp);
for(int i=last[u],v;i;i=e[i].nt)
if(son[u]!=(v=e[i].to) && fa[u]!=v)
dfs(v,v);
}

struct seg_tree{ll tag,val;}tr[N<<2];

inline void pushup(int k)
{tr[k].val=min(tr[k<<1].val,tr[k<<1|1].val);}

inline void pushdown(int k)
{
if(tr[k].tag)
{
ll tag=tr[k].tag;tr[k].tag=0;
tr[k<<1].tag+=tag;tr[k<<1|1].tag+=tag;
tr[k<<1].val-=tag;tr[k<<1|1].val-=tag;
}
}

void build(int k,int l,int r)
{
if(l==r)
{
tr[k].val=V[pos[l]]-S[pos[l]];
return ;
}
int mid((l+r)>>1);
build(k<<1,l,mid);build(k<<1|1,mid+1,r);
pushup(k);
}

int modify(int k,int l,int r,int x,int y,ll val)
{
if(l>=x&&r<=y && tr[k].val>=val)
{
tr[k].val-=val;
tr[k].tag+=val;
return 0;
}
if(l==r)
{
tr[k].val-=val;
if(tr[k].val+val<val) return pos[l];
return 0;
}
pushdown(k);
int mid=(l+r)>>1,res(0);
if(y>mid) res=modify(k<<1|1,mid+1,r,x,y,val);
if(!res && x<=mid) res=modify(k<<1,l,mid,x,y,val);
pushup(k);
return res;
}

ll query_S(int k,int l,int r,int x)
{
if(l==r) return V[pos[l]]-tr[k].val;
pushdown(k);
int mid=(l+r)>>1;
return x>mid ? query_S(k<<1|1,mid+1,r,x) : query_S(k<<1,l,mid,x);
}

ll query_F(int u)
{return min(V[u],query_S(1,1,n,dfn[u]));}

void get_modify(int u,ll val)
{
if(val<=0) return ;
while(u)
{
int tmp=modify(1,1,n,dfn[top[u]],dfn[u],val);
if(tmp)
{
get_modify(fa[tmp],V[tmp]-query_S(1,1,n,dfn[tmp])+val);
return ;
}
u=fa[top[u]];
}
}

int main()
{
n=read();
register int i,u,v;
for(i=1;i<=n;++i) V[i]=read();
for(i=1;i<n;++i)
{
u=read();v=read();
add(u,v);add(v,u);
}
dp(1);dfs(1,1);
build(1,1,n);
int Q=read();
char opt[2];
while(Q--)
{
scanf("%s",opt);
u=read();
switch(opt[0])
{
case 'C':
v=read();V[u]+=v;
if(v) modify(1,1,n,dfn[u],dfn[u],-v);
get_modify(fa[u],query_F(u)-V[u]+v);
break;
case 'Q':
print(query_F(u));puts("");
break;
}
}
return 0;
}