hdu 1561 The more,The better

树形依赖背包，用多叉转换成二叉的形式解决

一个节点两个孩子，左孩子是它的孩子中的第一个，右孩子是它的第一个右兄弟，这样一直递归下去，所以只有左孩子是节点的真正孩子

dp[i][j]=max{dp[r[i]][j], dp[l[i][k]] + dp[r[i]][j-1-k] +w[i] },0<=k<j

表示要么全部分配给兄弟节点，要么分给孩子一部分，分给兄弟一部分，既然要分给孩子，它自己就必须被选

代码：

include<iostream>
#include<memory.h>
#include<string>
#include<cstdio>
#include<algorithm>
#include<math.h>
#include<stack>
#include<queue>
#include<vector>
#include<map>
using namespace std;
const int MAX=205;
struct node 
{
	int v,next;
}g[MAX*MAX];
int adj[MAX],dp[MAX][MAX],val[MAX],e,n,m,l[MAX],r[MAX];
void add(int u,int v)
{
	g[e].v=v; g[e].next=adj[u]; adj[u]=e++;
}
void Tree_add(int u,int v)
{
	if(l[u]==-1)
	{
		l[u]=v;
	}
	else
	{
		u=l[u];
		while(r[u]!=-1)
			u=r[u];
		r[u]=v;
	}
}
void dfs(int u,int k)
{
	int i,j,v; 
	for(i=adj[u];i!=-1;i=g[i].next)
	{
		v=g[i].v;
		memcpy(dp[v],dp[u],sizeof(dp[u]));
		dfs(g[i].v,k-1);
		for(j=1;j<=k;j++)
		{
			dp[u][j]=max(dp[u][j],dp[v][j-1]+val[v]);
		}
	}
}
int dfs2(int u,int k)
{
	int i,v;
	int a1,a2,a3;
	if(u==-1||k==0)
		return 0;
	if(dp[u][k]!=-1)
		return dp[u][k];
	a1=dfs2(r[u],k);
	dp[u][k]=a1;
	for(i=0;i<k;i++)
	{
		a2=dfs2(l[u],i);
		a3=dfs2(r[u],k-1-i);
		//dp[u][k]=max(dp[u][k],a1+a2+val[u]);
		dp[u][k]=max(dp[u][k],a2+a3+val[u]);
	}
	return dp[u][k];
}
int main()
{
	int i,j,k,a,b;
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		if(m==0&&n==0)
			break;
		memset(adj,-1,sizeof(adj));
		memset(r,-1,sizeof(r));
		memset(l,-1,sizeof(l));
		e=0;
		memset(dp,-1,sizeof(dp));
		for(i=1;i<=n;i++)
		{
			scanf("%d%d",&a,&val[i]);
			add(a,i);
			Tree_add(a,i); 
		}
		//dfs(0,m);
		dfs2(0,m+1);
		printf("%d\n",dp[0][m+1]);
	}
	return 0;
}