POJ 2486 树形dp

题目大意：

从 1 号点出发，每次经过一个点，就可以得到点上的所有苹果，走m步，求能够得到的苹果最大数量

这里用dp[u][j] 表示 从u号点出发走 j 步后回到u点能得到的苹果最大数量

用ans[u][j] 表示从 u 号点出发走 j 步不一定回到u点能得到的苹果最大数量（包括了dp[u][j]的情况）

因为从父亲到儿子，最后又要回到父亲需要多走2次

dp[u][j+2] = max{dp[v][k] + dp[u][j-k]} k<=j , j<=m

对于ans[][]来说因为不确定它是否回到父亲，所以根据dp[][]来算

要从一棵子树到另一棵子树，那么必然经过父亲 ， 那么这两棵子树中可能是原子树回到了原点 ， 那么当前子树就没必要回到原点，那么当前边只要去不用回来

ans[u][j+1] = max{ans[v][k] + dp[u][j-k]}

又可能是当前子树回到了原点 ， 那么原子树就没必要回到原点，那么就是从父亲先去当前子树，再回来经过原来的子树合并，当前边来回就是多走两次

ans[u][j+2] = max{dp[v][k] + ans[u][j-k]}

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
const int N = 205;
int val[N] , first[N] , k , dp[N][N] , ans[N][N];

struct Edge{
    int y , next;
}e[N<<1];

void add_edge(int x, int y)
{
    e[k].y = y , e[k].next = first[x];
    first[x] = k++;
}

void dfs(int u , int fa , int m)
{
    ans[u][0] = dp[u][0] = val[u];
    for(int i = first[u] ; i!=-1 ; i=e[i].next){
        int v = e[i].y;
        if(v == fa) continue;
        dfs(v , u , m);
        for(int j=m ; j>=0 ; j--){
            for(int k=j ; k>=0 ; k--){
                dp[u][j+2] = max(dp[u][j+2] , dp[v][k] + dp[u][j-k]);
                ans[u][j+2] = max(dp[v][k] + ans[u][j-k] , ans[u][j+2]);
                ans[u][j+1] = max(ans[v][k] + dp[u][j-k] , ans[u][j+1]);
            }
        }
    }
}

int main()
{
  // freopen("a.in" , "r" , stdin);
    int n,m,x,y;
    while(scanf("%d%d" , &n , &m)==2)
    {
        for(int i=1 ; i<=n ; i++)
            scanf("%d" , val+i);
        memset(first , -1 , sizeof(first));
        k = 0;
        for(int i=1 ; i<n ; i++){
            scanf("%d%d" , &x , &y);
            add_edge(x , y);
            add_edge(y , x);
        }
        memset(ans , 0 , sizeof(ans));
        memset(dp , 0 , sizeof(dp));

        dfs(1 , -1 , m);

        int maxn = 0;
        for(int i=0 ; i<=m ; i++)
            maxn = max(maxn , ans[1][i]);
        printf("%d
" , maxn);
    }
    return 0;
}