poj 2486 树形dp

题意：一个叫Wshxzt的可爱的女孩子被HX大叔带到了一棵苹果树边。众所周知，苹果树是一个树形的结构，在节点处长有苹果（这明显不符合实际情况……）。现在我们知道Wshxzt是个苹果控，她只要访问到一个节点，就一定会吃光这个节点所有的苹果。HX大叔为了防止Wshzxt长胖，限制她只能走K（1 ≤ K ≤ 200）步，从一个节点走到另一个相邻的节点是所谓走一步。Wshxzt从节点1开始。树上的节点有N（1 ≤ N ≤ 100）个，你需要计算Wshxzt最多能吃到多少苹果。

思路：树形dp，比较经典的一个树形dp。首先很容易就可以想到用dp[root][k]表示以root为根的子树中最多走k时所能获得的最多苹果数，接下去我们很习惯地会想到将k步在root的所有子结点中分配，也就是进行一次背包，就可以得出此时状态的最优解了，但是这里还有一个问题，那就是在进行背包的时候，对于某个孩子son走完之后是否回到根结点会对后面是否还能分配有影响，为了解决这个问题，我们只需要在状态中增加一维就可以了，用dp[root][k][0]表示在子树root中最多走k步，最后还是回到root处的最大值，dp[root][k][1]表示在子树root中最多走k步，最后不回到root处的最大值。由此就可以得出状态转移方程了：

dp[root][j][0] = MAX (dp[root][j][0] , dp[root][j-k][0] + dp[v][k-2][0]);

dp[root][j]][1] = MAX( dp[root][j][1] , dp[root][j-k][0] + dp[v][k-1][1]) ;

dp[root][j][1] = MAX (dp[root][j][1] , dp[root][j-k][1] + dp[v][k-2][0]);

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<memory.h>
using namespace std;
int dp[202][402][2],n,k,NE;
int head[202],app[202];
struct node
{
int u,v,next,val;
} Edge[500];
void addEdge(int u,int v)
{
Edge[NE].u=u;
Edge[NE].v=v;
Edge[NE].next=head[u];
head[u]=NE++;
}
void dfs(int u,int fa)
{
int i,j,t;
for(i=head[u]; i!=-1; i=Edge[i].next)
{
int r=Edge[i].v;
if(r==fa) continue;
dfs(r,u);
for(j=k; j>=1; j--)
{
for(t=1; t<=j; t++)
{
dp[u][j][0]=max(dp[u][j][0],dp[u][j-t][1]+dp[r][t-1][0]);
dp[u][j][0]=max(dp[u][j][0],dp[u][j-t][0]+dp[r][t-2][1]);
dp[u][j][1]=max(dp[u][j][1],dp[u][j-t][1]+dp[r][t-2][1]);
}
}
}
}
int main()
{
int i,j,a,b;
while(scanf("%d%d",&n,&k)!=EOF)
{
NE=0;
memset(dp,0,sizeof(dp));
memset(head,-1,sizeof(head));
for(i=1; i<=n; i++)
{
scanf("%d",&app[i]);
for(j=0; j<=k; j++)
{
dp[i][j][1]=app[i];
dp[i][j][0]=app[i];
}
}
for(i=1; i<n; i++)
{
scanf("%d%d",&a,&b);
addEdge(a,b);
addEdge(b,a);
}
dfs(1,0);
cout<<max(dp[1][k][0],dp[1][k][1])<<endl;
}
return 0;
}
/*
2 1
1 11
1 2
3 2
1 1 2
1 2
1 3
7 7
1 2 1 3 5 1 1
1 2
2 4
2 5
1 3
3 6
3 7
7 4
1 2 1 3 5 1 1
1 2
2 4
2 5
1 3
3 6
3 7
*/