POJ 2486 树形dp

题意：一颗树，n个点（1-n），n-1条边，每个点上有一个权值，求从1出发，走V步，最多能遍历到的权值

dp[root][k]表示以root为根的子树中最多走k时所能获得的最多苹果数

在经典树形dp的套路上，注意到有时候走完一条路需要返回，此时需要考虑走完某个节点需不需要回来

dp[root][j][0] = M用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[son][k-2][0]);//从s出发，要回到s，需要多走两步s-t,t-s,分配给t子树k步，其他子树j-k步，都返回

dp[root][j]][1] = MAX(  dp[root][j][1] , dp[root][j-k][0] + dp[son][k-1][1]) ;//先遍历s的其他子树，回到s，遍历t子树，在当前子树t不返回，多走一步

dp[root][j][1] = MAX (dp[root][j][1] , dp[root][j-k][1] + dp[son][k-2][0]);//不回到s（去s的其他子树），在t子树返回，同样有多出两步

#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 5e4+7;
int n,kk;
int a[111],dp[111][222][2],c[111];
vector<int>q[111];
void dfs(int x,int fa)
{
    int i,j,k;c[x]=1;dp[x][0][0]=dp[x][0][1]=a[x];
    for(i=0;i<q[x].size();i++)
    {
        int u=q[x][i];if(u==fa) continue;
        dfs(u,x);c[x]+=c[u];
        for(j=kk;j>=1;j--)
        {
            for(k=1;k<=j;k++)
            {
                if(k-2>=0) dp[x][j][0]=max(dp[x][j][0],dp[x][j-k][0]+dp[u][k-2][0]);
                if(k-1>=0) dp[x][j][1]=max(dp[x][j][1],dp[x][j-k][0]+dp[u][k-1][1]);
                if(k-2>=0) dp[x][j][1]=max(dp[x][j][1],dp[x][j-k][1]+dp[u][k-2][0]);
            }
        }
    }
}
int main()
{
    int i,x,y;
    while(~scanf("%d%d",&n,&kk))
    {
        memset(c,0,sizeof(c));
        memset(dp,0,sizeof(dp));
        for(i=1;i<=n;i++) q[i].clear();
        for(i=1;i<=n;i++) {scanf("%d",a+i);for(int j=1;j<=kk;j++) dp[i][j][0]=dp[i][j][1]=a[i];}
        for(i=1;i<n;i++) scanf("%d%d",&x,&y),q[x].push_back(y),q[y].push_back(x);
        dfs(1,0);printf("%d\n",max(dp[1][kk][1],dp[1][kk][0]));
    }
}