poj 2486 apple tree

继续树形dp，这题比我之前写的都要难，我也犯2了，竟然拿以前的做法来套，套了半天换来的只是测试数据都过不了。

题意：一棵苹果树，以1当root，路过k条边，最终能吃到最多苹果的数量。

思路：开始就要弄清这个过程是有方向的，不然就跟我一样走进死胡同了。

dp[0][i][x]   以i为根节点，能返回i节点，并且走x步能活得的最大苹果数     dp[1][i][x]  以i为根节点，不能返回i节点，走x步获得的最大苹果数。   

走的时候只可能有3种情况：（a为根节点，b为a的儿子节点。）

①  a返回，b也返回。这种状况的终状态为能返回a

②  a返回， b不返回，这种状况的终状态是节点处于b子树中，a的终状态为不返回。

③ a不返回，b返回，这种状况的终状态是节点处于非b的子树中，a的终状态为不返回。

状态转移方程：(f为x的根节点) 

                 dp[0][x][j+2] = max(dp[0][x][j+2],dp[0][x][j-k]+dp[0][f][k]);   （ 注意：这里出现的2表示连接x与f的边需要走2次，这里出现的1表示连接x与f的边只需要走1次）
             dp[1][x][j+2] = max(dp[1][x][j+2],dp[0][f][k]+dp[1][x][j-k]);   
             dp[1][x][j+1] = max(dp[1][x][j+1],dp[1][f][k]+dp[0][x][j-k]);

</pre><pre name="code" class="cpp">#include<cstdio>
#include<iostream>
#include<cstring>
#define N 110
#define max(a1,b1) (a1)>(b1)?(a1):(b1)
using namespace std;
int n,k,tot;
int head[N],dp[2][N][210],cost[N];
bool vis[N];
struct Node{
int to,next;
};
Node edge[4*N];

void add_edge(int a,int b) {
    edge[tot].to = b;
    edge[tot].next = head[a];
    head[a] = tot++;
}

void dfs(int x) {
    for(int i=0;i<=k;++i)
    dp[0][x][i] = dp[1][x][i] = cost[x];
    for(int i=head[x];i!=-1;i=edge[i].next)
    {
        int f = edge[i].to;
        if(vis[f])
        continue;
        vis[f] = true;
        dfs(f);
        for(int j=k;j>=0;--j)
        {
         for(int k=0;k<=j;++k)
         {
             dp[0][x][j+2] = max(dp[0][x][j+2],dp[0][x][j-k]+dp[0][f][k]);
             dp[1][x][j+2] = max(dp[1][x][j+2],dp[0][f][k]+dp[1][x][j-k]);
             dp[1][x][j+1] = max(dp[1][x][j+1],dp[1][f][k]+dp[0][x][j-k]);
         }
        }
    }
}

int main(void)
{
    while(cin>>n>>k)
    {
        tot = 0;
        memset(head,-1,sizeof(head));
        memset(vis,false,sizeof(vis));
        for(int i=1;i<=n;++i)
        scanf("%d",&cost[i]);
        for(int i=1;i<n;++i)
        {
           int a,b;
           scanf("%d %d",&a,&b);
           add_edge(a,b);
           add_edge(b,a);

        }
        vis[1] = true;
        dfs(1);
        int ans = max(dp[0][1][k],dp[1][1][k]);
        cout<<ans<<endl;
    }

    return 0;
}