没有上司的舞会（树形DP）

题目描述

某大学有N个职员，编号为1~N。他们之间有从属关系，也就是说他们的关系就像一棵以校长为根的树，父结点就是子结点的直接上司。现在有个周年庆宴会，宴会每邀请来一个职员都会增加一定的快乐指数Ri，但是呢，如果某个职员的上司来参加舞会了，那么这个职员就无论如何也不肯来参加舞会了。所以，请你编程计算，邀请哪些职员可以使快乐指数最大，求最大的快乐指数。

输入格式

第一行一个整数N。(1<=N<=6000)

接下来N行，第i+1行表示i号职员的快乐指数Ri。(-128<=Ri<=127)

接下来N-1行，每行输入一对整数L,K。表示K是L的直接上司。

最后一行输入0 0

输出格式

输出最大的快乐指数。

输入输出样例

输入 #1复制

7
1
1
1
1
1
1
1
1 3
2 3
6 4
7 4
4 5
3 5
0 0

输出 #1复制

5

思路是将该关系视为一棵树，则以X为根的树的最大快乐指数等于MAX｛ X来的最大快乐指数，X不来的快乐指数  ｝

递推顺序按照树的深度推，则在推一个节点的最大快乐指数时，其子节点都会已经推出来了 

附BFS+一维递推  代码（因为是树形，其实记忆化递归也是可以，而且二维可能更加简洁）

#include<iostream>
#include<algorithm>
#include<list>
#include<queue>
#include<stack>
using namespace std;
//dp[root]=max(a[root]+dp[roots>son->son],dp[root->son])
struct worker {
	int p;  //父节点 
	list<int> son; //子节点 
	int ri;  //快乐指数 
	worker () {
		p=0;
	}
};
struct mypair {
	int son1; //各儿子节点来的快乐总数和 
	int son2;//各孙子节点来的快乐总数和 
	mypair (int x=0,int y=0) {
		son1=x;
		son2=y;
	}
};
int n,dp[6002];//DP[i]表示以第i个员工为根节点的树的最大快乐指数 
stack<int> s; //按树的深度存，则在推一个节点的最大快乐指数时，其子节点都会已经推出来了 
worker a[6002]; //各节点信息 
int findroot() {  //寻找根节点（校长） 
	for(int i=1; i<=n; i++)if(a[i].p==0)return i;
	return 0;
}
void bfs(int root) {// BFS得出树的深度序列，则在推一个节点的最大快乐指数时，其子节点都会已经推出来了 
	bool flag[6002]= {false};
	queue<int> que;
	que.push(root);
	flag[root]=true;
	while(!que.empty()) {
		int top=que.front();
		que.pop();
		s.push(top);
		for(list<int>::iterator i=a[top].son.begin(); i!=a[top].son.end(); i++) {
			if(flag[*i]==false) {
				que.push(*i);
				flag[*i]=true;
			}
		}
	}
}
mypair f(int root) {//返回一个包含儿子节点来的最大快乐指数，和孙子节点的最大快乐指数 
	mypair t;
	for(list<int>::iterator i=a[root].son.begin(); i!=a[root].son.end(); i++) {
		int x=*i;
		t.son1+=dp[x];
		for(list<int>::iterator j=a[x].son.begin(); j!=a[x].son.end(); j++) {
			t.son2+=dp[*j];
		}
	}
	return t;
}
int main() {
    cin>>n;
	for(int i=1; i<=n; i++) {
		cin>>a[i].ri;
	}
	int x,y;
	for(int i=0; i<n; i++) {
		cin>>x>>y;
		a[x].p=y;
		a[y].son.push_back(x);
	}
	int root =findroot();
	bfs(root);
	for(int i=1; i<=n; i++) {
		int top=s.top();
		s.pop();
		mypair t=f(top);
		dp[top]=max(a[top].ri+t.son2,t.son1);//递推式 
	}
	cout<<dp[root];
	return 0;
}