HDU 1520 Anniversary party （树形DP）

题目链接

这题和 POJ 2342 还有 URAL 1039 一样，只不过测试了HDU的数据应该是最严格的一个，因此选了HDU的链接。

思路：我们考虑从最大boss开始搜索整颗树，其次这个boss只有两种状态就是去或者不去，然后他的状态会影响他的直属员工的选择，也就是 1.当这个boss去的时候，下属必然不能去；2.当这个boss不去的时候，下属可去可不去；

然后我们单纯考虑这个boss下属的时候，也是一样的。

状态转移方程：1. dp[i][0] += max(dp[j][0],dp[j][1]) //表示第i个人不去，j表示这个人所有的下属

                        2. dp[i][1] += dp[j][0] //表示第i个人去，则他所有的下属都去不了

然后就是建立这颗树，从根开始搜索。

值得注意的是，一开始我为了代码简单点，用一维数组记录每个人的boss是谁，然后在每层搜索的时候都遍历一遍这个数组，来找boss是当前搜索这个人的员工，这样虽然代码上简单了一点，但是效率是很低的，时间复杂度就就成了O（n^2）。POJ和URAL都能过，而HDU会超时，这也是我上面说的HDU数据最严的原因。所以我后来还是改成了用邻接矩阵来建立图。

代码：

import java.util.*;

public class Main{
	static Scanner sc = new Scanner(System.in);
	static int n;
	static int [] v;
	static Vector<Integer> [] tree;
	static int []  boss; //是为了记录各个点的boss，然后在搜索之前找到树根用的
	static boolean [] vis;
	static int [][] dp;
	static void f(int cur) {
		vis[cur] = true;
		dp[cur][1] = v[cur];
		int len = tree[cur].size();
		for(int i = 0; i < len; i++) {
			int son = tree[cur].get(i);
			if(!vis[son]) {
				f(son);
				dp[cur][1] += dp[son][0];
				dp[cur][0] += Math.max(dp[son][0], dp[son][1]);
			}
		}
	}
	public static void main(String[] args) {
		while(sc.hasNext()) {
			n = sc.nextInt();
			dp = new int[n+1][2];
			v = new int[n+1];
			boss = new int[n+1];
			tree = new Vector[n+1];
			vis = new boolean[n+1];
			for(int i = 1; i <= n; i++) {
				v[i] = sc.nextInt();
				tree[i] = new Vector<Integer>();
			}
			
			int s,f;
			int root = 1, first = 1;
			while(true) {
				s = sc.nextInt(); f = sc.nextInt(); 
				if(s == 0 && f == 0) break;
				boss[s] = f;
				tree[f].add(s);
				if(root == s || first == 1) {
					root = f;
					if(first == 1) first--;
				}
			}
			
			while(true) {
				if(boss[root] == 0) break;
				root = boss[root];
			}
			
			f(root);
			System.out.println(Math.max(dp[root][0], dp[root][1]));
		}
		System.exit(0);
	}
}