HDOJ 4276 The Ghost Blows Light（最短路+树形DP）鬼吹灯问题

/*
参考：http://nightelf.sinaapp.com/2012/hdu-4276.html
鬼吹灯问题
题意：每个坟墓都有一些珠宝，从一个坟墓到另一个坟墓需要耗费掉一定的时间，问从1到N，在规定时间T内，最多可以得到珠宝数
思路：最短路+树形DP，找出从1到N的最短路，因为任何两点间只有一条路，所以最短路中所有边都为必走的边。所以从1到N的路径，都为最短路，
然后加上从最短路中某些个节点拓展出的一个环。对每个节点进行树形DP，完成后，再次对最短路所有节点进行一次DP。
这道题收获：
①使用STL会让代码简单很多，vector避免了图向树的转换
②对d进行赋值为-1，在进行DP时候，都所有元素进行判断，这样会使程序可读性好一些。如果熟练了，在直接使用-INF
*/

#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;
int N, T;
const int nMax = 107;
const int tMax = 507;
const int INF = 0x3fffffff;
int A[nMax];
int mark[nMax];
int d[nMax][tMax];

struct Data
{
	int y, t;
	Data(){}
	Data(int y, int t):y(y), t(t){}
};
vector<Data> G[nMax];

int bfs()
{
	int i;
	int dis[nMax];
	int fa[nMax];
	queue<int> que;
	que.push(1);
	memset(fa, -1, sizeof(fa));
	//memset(dis, -1, sizeof(dis));
	for(i = 1; i <= N; ++ i) dis[i] = INF;
	dis[1] = 0;
	int vis[nMax];
	memset(vis, 0, sizeof(vis));
	while(!que.empty())
	{
		int q = que.front();
		que.pop();
		vis[q] = 0;
		for(i = 0; i < G[q].size(); ++ i)
		{
			Data tmp = G[q][i];
			if(dis[tmp.y] > dis[q] + tmp.t)
			{
				dis[tmp.y] = dis[q] + tmp.t;
				fa[tmp.y] = q;
				if(!vis[tmp.y])
				{
					vis[tmp.y] = 1;
					que.push(tmp.y);
				}
			}
		}
	}
	memset(mark, 0, sizeof(mark));
	for(i = N; i != -1; i = fa[i])
		mark[i] = 1;
	return dis[N];
}


void dfs(int root, int pre, int Max)
{
	memset(d[root], -1, sizeof(d[root]));
	d[root][0] = A[root];
	int rt, i, j;
	for(rt = 0; rt < G[root].size(); ++ rt)
	{
		Data tmp = G[root][rt];
		if(tmp.y != pre && !mark[tmp.y])
		{
			dfs(tmp.y, root, Max);
			for(i = Max; i > 0; -- i)
			{
				for(j = 0; j <= i; ++ j)
				{
					if(i - j - 2 * tmp.t >= 0 && d[tmp.y][j] != -1 && d[root][i - j - 2 * tmp.t] != -1)//②
						if(d[root][i] < d[tmp.y][j] + d[root][i - j - 2 * tmp.t])
							d[root][i] = d[tmp.y][j] + d[root][i - j - 2 * tmp.t];
				}
			}
		}
	}
}

int main()
{
	//freopen("e://data.in", "r", stdin);
	while(scanf("%d%d", &N, &T) != EOF)
	{
		int a, b, t;
		int i, j, k;
		memset(G, 0, sizeof(G));
		for(i = 1; i < N; ++ i) 
		{
			scanf("%d%d%d", &a, &b, &t);
			G[a].push_back(Data(b, t));
			G[b].push_back(Data(a, t));
		}
		for(i = 1; i <= N; ++ i) scanf("%d", &A[i]);

		int tt = bfs();
		if(tt == -1 || tt > T)
		{
			printf("Human beings die in pursuit of wealth, and birds die in pursuit of food!\n");
			continue;
		}
		int Max = T - tt;
		for(i = 1; i <= N; ++ i)
		{
			if(mark[i])
				dfs(i, -1, Max);
		}
		int DP[tMax];
		memset(DP, -1, sizeof(DP));
		DP[0] = 0;
		for(i = 1; i <= N; ++ i)
		{
			if(!mark[i]) continue;
			for(j = Max; j >= 0; -- j)
				for(k = 0; k <= j; ++ k)
				{
					if(j - k >= 0 && d[i][k] != -1 && DP[j - k] != -1)
						if(DP[j] < d[i][k] + DP[j - k])
							DP[j] = d[i][k] + DP[j - k];
				}
		}
		int _max = 0;
		for(j = 0; j <= Max; ++ j)
			if(_max < DP[j])
				_max = DP[j];
		printf("%d\n", _max);
	}
	return 0;
}