Vijos1144 皇宫看守 （0/1/2三种状态的普通树形Dp）

题意：

给出一个树以及一些覆盖每个点的花费，求每个点都能被自己被覆盖，或者相邻的点被覆盖的最小价值。

细节：

其实我乍一眼看过去还以为是 战略游戏 的复制版 可爱的战略游戏在这里QAQ（请原谅这波广告）

显然这是一个巨坑，所以必须先来看一张神奇的图片~ ~ ~ ~ ~

帅气的图片在这里QVQ

我们显然很轻松的找出了反例，那该如何解决呢？

分析：

不难发现对于从上往下的第二个节点，它的儿子和它都不需要被覆盖也是合法的，所以对于一个节点在图中来说，合法状态有：它被覆盖其儿子父亲都被覆盖或都不被或其中一个被覆盖，它不被覆盖其儿子父亲都被覆盖或其中一个被覆盖。

所以对于一个节点来说它的状态有：1.它的父亲被覆盖； 2.它的儿子被覆盖； 3.它自己被覆盖；

所以状态 dp[u][0/1/2] 表示的就是上述三种情况

转移如下：

dp[u][0] = ∑ min( dp[v][1] , dp[v][2])

dp[u][1] = ∑ min( dp[v][1] , dp[v][2]) + del

dp[u][2] = ∑ min( dp[v][1] , dp[v][2] , dp[v][0] ) + val[u]

del = min( dp[v][2] - min(dp[v][1] , dp[v][2] )

del 指的是什么？首先关键还是在于状态节点 u 被其儿子覆盖的合法状态，这就说明了其儿子之中必须存在一个节点是把自己覆盖的，所以我们只要最有加上这个 del 问题就迎刃而解啦~~~

代码：

#include<bits/stdc++.h>
#define MAXN 300005
#define LL long long
using namespace std;

int val[MAXN], n;
vector<int> Right[MAXN];
LL f[MAXN][3];

void dfs(int u, int fa){
	f[u][0]=0, f[u][1]=0, f[u][2]=val[u];
	LL del=3000000000ll;
	for (int i=0; i<Right[u].size(); i++) {
		int v=Right[u][i];
		if (v==fa) continue;
		dfs(v, u);
		f[u][0]+=min(f[v][1], f[v][2]);
		f[u][1]+=min(f[v][1], f[v][2]);
		f[u][2]+=min(f[v][0], min(f[v][1], f[v][2]));
		del=min(del, f[v][2]-min(f[v][1], f[v][2]));
	}
	f[u][1]+=del;
}

int main(){
	scanf("%d", &n);
	for (int i=1, x, num; i<=n; i++) {
		scanf("%d", &x);
		scanf("%d%d", &val[x], &num);
		for (int j=1, y; j<=num; j++){
			scanf("%d", &y);
			Right[x].push_back(y);
			Right[y].push_back(x);
		}
	}
	dfs(1, 0);
	printf("%lld\n", min(f[1][1], f[1][2]));
	return 0;
}