HDU 4616 Game

树形DP

题意：给一棵树，树上的每个节点会有财富，某些节点会有陷阱，现在你可以从任意节点开始走，不能往回走，碰到第C个陷阱就停，问能获得的最大价值。

思路：开三维状态，分别是【当前节点】【已经遇到的陷阱数】【是否从陷阱开始】，值表示从这个节点的子节点在相应情况下能取得的最大值。那么最长的那条路必然是由两棵子树的最大值合并而成或者就是从这个节点到子树的某处的价值。

需要注意的是合并时候的情况。当遇到的陷阱树小于C的时候，两条子路可以任意取，而当遇到的陷阱数等于C的时候，只能是以一个陷阱处结束这种情况（当笔者写完这句话的时候，突然发现这丫就是个大水题啊，卡两天这智商是什么情况T_T）

然后就是取子路的时候注意不能取到同一棵子树，所以需要保存最大和次大两个价值以及它们来自的节点

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define clr(a,b) memset((a),(b),sizeof(a))

int max(int a, int b) { return a>b?a:b; }
int min(int a, int b) { return a<b?a:b; }

const int MAXN = 50010;
int trap[MAXN],w[MAXN];
int m1[MAXN][6][2],m2[MAXN][6][2];
int rt1[MAXN][6][2],rt2[MAXN][6][2];
int head[MAXN],tot;
struct E{
	int v, next;
}edge[MAXN<<1];
int n,C;
int ans ;

int cal(int u,int i,int k,int j, int r)
{
	int ret = m1[u][i][k] + w[u];
	if(rt1[u][i][k] == rt1[u][j][r]) ret += m2[u][j][r];
	else ret += m1[u][j][r];

	int ret2 = m1[u][j][r] + w[u];
	if(rt1[u][i][k] == rt1[u][j][r]) ret2 += m2[u][i][k];
	else ret2 += m1[u][i][k];

	return max(ret,ret2);
}

void dfs(int u, int fa)
{
	int p,i,j,k,r,temp;
	for(p=head[u]; p!=-1; p=edge[p].next)
	{
		int v = edge[p].v;
		if(v == fa) continue;
		dfs(v,u);
		for(i=0; i<=C; i++)
		{
			for(k=0; k<2; k++)
			{
				if(m1[v][i][k] > m2[u][i][k])
				{
					m2[u][i][k] = m1[v][i][k];
					rt2[u][i][k] = v;
					if(m1[u][i][k] < m2[u][i][k])
					{
						swap(m1[u][i][k], m2[u][i][k]);
						swap(rt1[u][i][k], rt2[u][i][k]);
					}
				}
			}
		}
	}

	//计算等于C的情况
	for(i=0; i<=C; i++)
	{
		j = C-trap[u]-i;
		if(j <= 0) break;
		for(k=0; k<2; k++)
		{
			temp = cal(u,i,k,j,1);
			if(temp > ans) ans = temp;
		}
	}

	// 计算小于C的情况
	for(i=0; i<=C; i++)
	{
		for(j=0; j<=C; j++)
		{
			if(i+j+trap[u] >= C) break;
			for(k=0; k<2; k++)
			{
				for(r=0; r<2; r++)
				{
					temp = cal(u,i,k,j,r);
					if(temp > ans) ans = temp;
				}
			}
		}
	}

	if(trap[u])
	{
		for(i=C-1; i>=0; i--)
		{
			m1[u][i+1][1] = m1[u][i][1] + w[u];
			if(m1[u][i][0]) m1[u][i+1][0] = m1[u][i][0] + w[u], m1[u][i][0] = 0;
		}
		m1[u][1][1] = w[u];
		m1[u][0][1] = 0;
	}
	else
	{
		for(i=C; i>=0; i--)
		{
			m1[u][i][0] += w[u];
			if(m1[u][i][1]) m1[u][i][1] += w[u];
		}
	}

	ans = max(ans, m1[u][C][1]);
	if(trap[u]) ans = max(ans, m1[u][C][0]);

	for(i=0; i<C; i++)
	{
		for(k=0; k<2; k++)
		{
			ans = max(ans, m1[u][i][k]);
		}
	}
}


void init()
{
	clr(m1,0);
	clr(m2,0);
	clr(rt1,-1);
	clr(rt2,-1);
	clr(head,-1);
	tot = 0;
	ans = -1;
}

void add_edge(int a, int b)
{
	edge[tot].next = head[a];
	edge[tot].v = b;
	head[a] = tot ++;
}

int main()
{
	int cas;
	int a,b;
	int i;
	scanf("%d", &cas);
	while(cas--)
	{
		scanf("%d%d", &n, &C);
		init();
		for(i=0; i<n; i++)
		{
			scanf("%d%d", &w[i], &trap[i]);
			ans = max(ans, w[i]);
		}
		for(i=0; i<n-1; i++)
		{
			scanf("%d%d", &a, &b);
			add_edge(a,b);
			add_edge(b,a);
		}
		dfs(0,-1);
		printf("%d\n", ans);
	}
	return 0;
}