【SSL1608】皇宫看守

Description

太平王世子事件后，陆小凤成了皇上特聘的御前一品侍卫。
皇宫以午门为起点，直到后宫嫔妃们的寝宫，呈一棵树的形状；某些宫殿间可以互相望见。大内保卫森严，三步一岗，五步一哨，每个宫殿都要有人全天候看守，在不同的宫殿安排看守所需的费用不同。
可是陆小凤手上的经费不足，无论如何也没法在每个宫殿都安置留守侍卫。

帮助陆小凤布置侍卫，在看守全部宫殿的前提下，使得花费的经费最少。

Input

输入文件中数据表示一棵树，描述如下：
第1行 n，表示树中结点的数目。
第2行至第n+1行，每行描述每个宫殿结点信息，依次为：该宫殿结点标号i（0对于一个n（0 < n<=1500）个结点的树，结点标号在1到n之间，且标号不重复。

Output

输出文件仅包含一个数，为所求的最少的经费。
Sample Output

Sample Input

6
1 30 3 2 3 4
2 16 2 5 6
3 5 0
4 4 0
5 11 0
6 5 0

Sample Output

25

思路：
我们先设
$$1:f[i][1]为当前i节点放守卫，需要的最小费用$$
$$2:f[i][2]为当前i节点不放守卫，被它的子节点监视$$
$$3:f[i][3]为当前i节点不放守卫，被它的父亲监视$$
然后一步步思考，怎么样转移

---

首先，我们思考1
如果它当前放守卫，那么它的儿子节点可放可不放，都会被监视。于是，我们就有：

for(int i=head[x]; i; i=b[i].next)
{
	long long y=b[i].to;
	VL_dp(y);
	f[x][1]+=min(f[y][1], min(f[y][2], f[y][3]));
}

---

然后，我们思考2
我们先分析2代表当前i节点不放守卫，被它的子节点监视，也就是不是它去监视它儿子，那我们可以在它儿子这里放守卫，也可以在它儿子的儿子放守卫，就会监视到它儿子。
然后我们思考，当前$x$必须要被其中一个儿子监视，也就是说要在它众多儿子中选一个出来监视，于是这个儿子就必须放守卫，我们就有：

long long tmp=0;
for(int i=head[x]; i; i=b[i].next)
{
	int y=b[i].to;
	tmp+=min(f[y][1], f[y][2]);//在儿子这放，还是在儿子的儿子放，哪个优
}
f[x][2]=2147483647;
for(int i=head[x]; i; i=b[i].next)
{
	int y=b[i].to;
	f[x][2]=min(f[x][2], tmp-min(f[y][1], f[y][2])+f[y][1]);//挑选出一个儿子用来监视它
}

---

最后我们思考3
3就比较简单，被父亲监视，也就是说它儿子必须被它儿子的儿子监视，这样它儿子才不会监视到它。最后我们就有：

for(int i=head[x]; i; i=b[i].next)
{
	long long y=b[i].to;
	f[x][3]+=f[y][2]; 
}

---

总结代码：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<queue>
#include<stack>
using namespace std;

long long n, tot, v[1001000], head[1001000], a[1000100];

long long f[1001000][4];

struct node
{
	long long to, next;
}b[1000100];

void VL_ljb(long long x, long long y)
{
	b[++tot]=(node){y, head[x]};
	head[x]=tot;
}

void VL_dp(long long x)
{
	for(int i=head[x]; i; i=b[i].next)
	{
		long long y=b[i].to;
		VL_dp(y);
		f[x][1]+=min(f[y][1], min(f[y][2], f[y][3]));
		f[x][3]+=f[y][2]; 
	}
	f[x][1]+=a[x];
	long long tmp=0;
	for(int i=head[x]; i; i=b[i].next)
	{
		int y=b[i].to;
		tmp+=min(f[y][1], f[y][2]);
	}
	f[x][2]=2147483647;
	for(int i=head[x]; i; i=b[i].next)
	{
		int y=b[i].to;
		f[x][2]=min(f[x][2], tmp-min(f[y][1], f[y][2])+f[y][1]);
	}
}

int main()
{
	scanf("%lld", &n);
	for(long long i=1; i<=n; i++)
	{
		long long x;
		scanf("%lld", &x);
		scanf("%lld", &a[x]);
		long long k;
		scanf("%lld", &k);
		for(long long j=1; j<=k; j++)
		{
			long long y;
			scanf("%lld", &y);
			VL_ljb(x, y);//有向图
			v[y]++;//从根开始，因为它是棵树
		} 
	}
	for(int i=1; i<=n; i++)
	{
		if(v[i]==0)
		{
			VL_dp(i);
			printf("%lld", min(f[i][1], f[i][2]));//根已经没有父节点了，所以不用3
		}
	}
	return 0;
}