hdoj 1011 Starship Troopers(树状DP)

/*
这道题还不错，四星

题意：N个洞，M个士兵，每个洞中有a个bug，b个brain，每个士兵可以处理20个bug，入口在洞口1处，问可以得到多少个brain。

思路：0-1背包问题
状态方程：d[a][b] = max(d[a][b - k] + d[j][k])，其中a、j之间有边相连。d[a][b]表示以a为根节点的子树，包含b个士兵，所能得到最大brain。
按a来分层进行动态规划。

基础的动态规划，还是要学会非递归处理，否则会增加算法的复杂度。不要对自己设限，这样才能找到最佳方法。
这道题，因为太熟悉递归了，所以花费了蛮多时间在转换思维。
*/

#include <iostream>
//#define TEST
using namespace std;
const int nMax = 105;
int map[nMax][nMax];
int d[nMax][nMax];
int visit[nMax];

struct Room
{
	int bugs, brains;
}room[nMax];
int N, M;


void dp(int u)//这里的动态规划，等于分层处理，每次处理一层。递归非递归相互配合。
{
	visit[u] = 1;
	int r = (room[u].bugs + 19) / 20;
	for(int i = M; i >= r; i --)
		d[u][i] = room[u].brains;//初始化
	for(int v = 1;v <= N; ++ v)
	{
		if(map[u][v] && !visit[v])
		{
			dp(v);
			for(int j = M; j >= r; j --)//这里需要注意，从大到小，这样可以避免自身节点的干扰。这里的d只需要处理其他子树
			{
				//这里如果想使用递归，则从M到r，执行对u的更新处理即可。
				for(int k = 1; k <= j - r; k ++)
					d[u][j] = max(d[u][j], d[u][j - k] + d[v][k]);
			}
		}
	}
}

int main()
{
	//freopen("e://data.txt", "r", stdin);
	while(scanf("%d%d", &N, &M) != EOF)
	{
		if(N == -1) break;
		for(int i = 1; i <= N; ++ i)
			scanf("%d%d", &room[i].bugs, &room[i].brains);
		memset(map, 0, sizeof(map));
		for(int i = 1; i < N; ++ i)
		{
			int a, b;
			scanf("%d%d", &a, &b);
			map[a][b] = map[b][a] = 1;
		}
		if(!M) //如果M为零，需要特殊判断，特殊数据
		{
			printf("0\n");
			continue;
		}
		memset(d, 0, sizeof(d));
		memset(visit, 0, sizeof(visit));
		dp(1);
		printf("%d\n", d[1][M]);
	}
	return 0;
}