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[N],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[N],S[N],F[N];

int fa[N],son[N],size[N];

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[N],pos[N],tim,top[N];

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;
}