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;

}