POJ2486 - Apple Tree(树形DP)

题目大意

给定一棵n个结点的树，每个结点上有一定数量的苹果，你可以从结点1开始走k步(从某个结点走到相邻的结点算一步)，经过的结点上的苹果都可以吃掉，问你最多能够吃到多少苹果？

题解

蛋疼的问题就是可以往回走~~~~想N就木有想到解法，看了下网上的解题报告~~~~想到了其实还是挺容易理解的~~~分为两种情况，就是有些点只需要走一次，而有些则需要走两次。

方程表示：

dp[0][u][j]表示从结点u开始走j步并且返回到结点u获得的最大价值

dp[1][u][j]表示从结点u开始走j步不回到结点u获得的最大值

dp[0][u][j]=max(dp[0][u][j],dp[0][u][j-k-2]+dp[0][v][k])(子节点v走完k步之后返回v,边(u,v)走了两次，所以其他子树需要走j-k-2步，并且也返回)

dp[1][u][j]=max(dp[1][u][j],dp[1][u][j-k-2]+dp[0][v][k])(子树v走完k步返回结点u，同样,边(u,v)走了两次，所以其他子树也需要走j-k-2步，不返回)

dp[1][u][j]=max(dp[1][u][j],dp[0][u][j-k-1]+dp[1][v][k])(先从结点u开始在除子树v外其他的子树走j-k-1步并且返回，边(u,v)只需要走一次,然后再在子树v走k步,不返回)

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;
#define MAXN 105
vector<int> G[MAXN];
int dp[2][MAXN][MAXN*2],value[MAXN];
int n,m;
void dfs(int u,int fa)
{
    for(int i=0;i<=m;i++) 
    {
        dp[0][u][i]=dp[1][u][i]=value[u];
    }
    for(size_t i=0;i<G[u].size();i++)
    {
        int v=G[u][i];
        if(fa==v) continue;
        dfs(v,u);
        for(int j=m-1;j>=0;j--)
        {
            for(int k=0;k<=j;k++)
            {
                dp[0][u][j+2]=max(dp[0][u][j+2],dp[0][u][j-k]+dp[0][v][k]);
                dp[1][u][j+2]=max(dp[1][u][j+2],dp[1][u][j-k]+dp[0][v][k]);
                dp[1][u][j+1]=max(dp[1][u][j+1],dp[0][u][j-k]+dp[1][v][k]);
            }
        }
    }
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(int i=1;i<=n;i++) 
            scanf("%d",&value[i]);
        for(int i=0;i<MAXN;i++) G[i].clear();
            memset(dp,0,sizeof(dp));
        for(int i=1;i<n;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        dfs(1,-1);
        printf("%d\n",max(dp[0][1][m],dp[1][1][m]));
    }
    return 0;
}