POJ 1155 TELE - 树形DP

一道类似于背包的题，一眼便能看出是树形DP

树形DP大概的思想大概就是虚树思想：先选定一个子节点，然后以此节点作为左儿子和右边一个儿子合并共同记为左儿子，其他右儿子一个个向左合并。

dp[i][j]意为编号为i的节点的所有子树共同选定j个用户所获得的利润，利润为负则是亏本。

一开始肯定都要赋-INF 的初值

DP方程很好写啊：

for(int j=m;j>=0;j--)//枚举根节点能取得用户数
for(int k=0;k<=size[e[i].to];k++)//枚举子节点能取得的用户数
dp[x][j]=max(dp[x][j],dp[e[i].to][k]+dp[x][j-k]-e[i].val);//原本的子节点的状态和新子节点的合并

然而写完这个以后完全过不了样例。。。-INF互加是个什么鬼。。。

后来发现别人代码都有判断是否可以转移的步骤，加一个if，如果需要转移的两个状态有一个为-INF（即无状态转移到此状态）则必定不能选

然后发现还是过不了。。。老爆0是个什么操作。。。

然后加一个初值就好了

一般这种题的套路就是

1)初值

2)for枚举子树，递归+合并

3)给不合理的越界情况赋-1

#include<iostream>
#include<cstdlib>
#include<cstdio> 
#include<cstring>
#include<algorithm>

using namespace std;

const int maxn=3005;
const int INF=0x3f3f3f3f;

struct edge
{
	int to,next,val;
}e[maxn];

int n,m,cnt;
int size[maxn],dp[maxn][maxn],head[maxn],s[maxn];

void insert(int a,int b,int val)
{
	e[++cnt].to=b;e[cnt].val=val;e[cnt].next=head[a];head[a]=cnt;
}

void dfs(int x)
{
	size[x]=1;
	dp[x][0]=0;
	for(int i=head[x];i;i=e[i].next)
	{
		dfs(e[i].to);
		size[x]+=size[e[i].to];
		for(int j=m;j>=0;j--)
			for(int k=0;k<=size[e[i].to];k++)
				if(dp[e[i].to][k]!=-INF&&dp[x][j-k]!=-INF)
					dp[x][j]=max(dp[x][j],dp[e[i].to][k]+dp[x][j-k]-e[i].val);
	}
	if(x>=n-m+1)
		dp[x][1]=s[x-n+m];
	for(int i=m;i>=0;i--)if(i>size[x])dp[x][i]=-INF;
}
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n-m;i++)
	{
		int a,b,c;
		scanf("%d",&c);
		while(c--)
		{
			scanf("%d%d",&a,&b);
			insert(i,a,b);
		}
	}
	for(int i=1;i<=m;i++)
		scanf("%d",s+i);
	memset(dp,-INF,sizeof dp);
	dfs(1);
	for(int i=m;i>=0;i--)
		if(dp[1][i]>=0||!i)
	{
		printf("%d",i);
		return 0;
	}
}