【bzoj4712】洪水 树链剖分+线段树维护树形动态dp

题目描述

给出一棵树，点有点权。多次增加某个点的点权，并在某一棵子树中询问：选出若干个节点，使得每个叶子节点到根节点的路径上至少有一个节点被选择，求选出的点的点权和的最小值。

输入

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

接下来一行包含n个数，表示第i个点的权值。

接下来n-1行每行包含两个数fr，to。表示书中有一条边（fr，to）。

接下来一行一个整数，表示操作的个数。

接下来m行每行表示一个操作，若该行第一个数为Q，则表示询问操作，后面跟一个参数x，表示对应子树的根；若

为C，则表示修改操作，后面接两个参数x，to，表示将点x的权值加上to。

n<=200000，保证任意to都为非负数

输出

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

样例输入

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

样例输出

3
1
4

---

题解

树链剖分+线段树维护树形动态dp

关于动态dp可以参考陈俊锟的PPT。

如果dp是静态的，设 $f[i]$ 表示以 $i$ 为根的子树满足条件的最小代价，那么有：$f[i]=\text{min}(v[i],\sum\limits_{i\to j}f[j])$ 。

当这个dp在序列上进行时，我们比较容易使用线段树维护序列动态dp。

当这个dp在树上进行时，考虑将这棵树轻重链剖分，转化为序列问题。

设 $y$ 为 $x$ 的重儿子，所有 $x$ 的轻儿子的 $f$ 值之和为 $g[x]$ ，那么有：$f[x]=\text{min}(v[x],f[y]+g[x])$ 。

这个形式类似于最小连续子段和中的最小前缀和。使用线段树维护最小前缀和（在重链这一段区间的某位置选出一个点使得总代价 $前面的g+当前的v$ 最小）及总和（这段区间都不选，所有的 $g$ 之和）。线段树的叶子节点有：最小前缀和为 $v$ ，总和为 $g$ 。

当修改时，首先影响到的时修改节点所在的重链，我们把对应节点的 $v$ 修改；然后会影响链顶的 $f$ 值，影响轻链的转移，再不断把链顶的父亲节点的 $g$ 修改。

当查询时，直接查询所求点所在重链上，该点到链底在线段树上的最小前缀和即为答案。

时间复杂度：修改时为 $O(\log^2n)$ ，查询时为 $O(\log n)$ 。

#include <cstdio>
#include <cstring>
#include <algorithm>
#define N 200010
#define lson l , mid , x << 1
#define rson mid + 1 , r , x << 1 | 1
using namespace std;
typedef long long ll;
struct data
{
	ll sum , ls;
	data() {}
	data(ll g , ll v) {sum = g , ls = v;}
	inline data operator+(const data &a)const
	{
		return data(sum + a.sum , min(sum + a.ls , ls));
	}
}a[N << 2] , w[N];
int head[N] , to[N << 1] , next[N << 1] , cnt , fa[N] , si[N] , bl[N] , end[N] , pos[N] , tot , n;
ll v[N] , f[N] , g[N];
char str[5];
inline void add(int x , int y)
{
	to[++cnt] = y , next[cnt] = head[x] , head[x] = cnt;
}
void dfs1(int x)
{
	int i;
	si[x] = 1;
	for(i = head[x] ; i ; i = next[i])
		if(to[i] != fa[x])
			fa[to[i]] = x , dfs1(to[i]) , si[x] += si[to[i]];
}
void dfs2(int x , int c)
{
	int i , k = 0;
	bl[x] = c , pos[x] = ++tot , end[x] = x , f[x] = v[x];
	for(i = head[x] ; i ; i = next[i])
		if(to[i] != fa[x] && si[to[i]] > si[k])
			k = to[i];
	if(k)
	{
		dfs2(k , c) , end[x] = end[k];
		for(i = head[x] ; i ; i = next[i])
			if(to[i] != fa[x] && to[i] != k)
				dfs2(to[i] , to[i]) , g[x] += f[to[i]];
		f[x] = min(f[x] , f[k] + g[x]);
	}
	w[pos[x]] = data(g[x] , v[x]);
}
inline void pushup(int x)
{
	a[x] = a[x << 1] + a[x << 1 | 1];
}
void build(int l , int r , int x)
{
	if(l == r)
	{
		a[x] = w[l];
		return;
	}
	int mid = (l + r) >> 1;
	build(lson) , build(rson);
	pushup(x);
}
void updatev(int p , ll v , int l , int r , int x)
{
	if(l == r)
	{
		a[x].ls += v;
		return;
	}
	int mid = (l + r) >> 1;
	if(p <= mid) updatev(p , v , lson);
	else updatev(p , v , rson);
	pushup(x);
}
void updateg(int p , ll g , int l , int r , int x)
{
	if(l == r)
	{
		a[x].sum += g;
		return;
	}
	int mid = (l + r) >> 1;
	if(p <= mid) updateg(p , g , lson);
	else updateg(p , g , rson);
	pushup(x);
}
data query(int b , int e , int l , int r , int x)
{
	if(b <= l && r <= e) return a[x];
	int mid = (l + r) >> 1;
	if(e <= mid) return query(b , e , lson);
	else if(b > mid) return query(b , e , rson);
	else return query(b , e , lson) + query(b , e , rson);
}
inline void modify(int x , ll v)
{
	int y = x;
	ll t;
	while(x)
	{
		t = query(pos[bl[x]] , pos[end[x]] , 1 , n , 1).ls;
		if(x == y) updatev(pos[x] , v , 1 , n , 1);
		else updateg(pos[x] , v , 1 , n , 1);
		v = query(pos[bl[x]] , pos[end[x]] , 1 , n , 1).ls - t , x = fa[bl[x]];
	}
}
int main()
{
	int m , i , x , y;
	ll z;
	scanf("%d" , &n);
	for(i = 1 ; i <= n ; i ++ ) scanf("%lld" , &v[i]);
	for(i = 1 ; i < n ; i ++ ) scanf("%d%d" , &x , &y) , add(x , y) , add(y , x);
	dfs1(1) , dfs2(1 , 1);
	build(1 , n , 1);
	scanf("%d" , &m);
	while(m -- )
	{
		scanf("%s%d" , str , &x);
		if(str[0] == 'C') scanf("%lld" , &z) , modify(x , z);
		else printf("%lld\n" , query(pos[x] , pos[end[x]] , 1 , n , 1).ls);
	}
	return 0;
}