POJ 2486 Apple Tree（树形dp）

题目大意

这道题的意思就是从根节点开始走k步能得到的最大价值。

题目分析

树形dp。首先很容易就可以想到用dp[root][k]表示以root为根的子树中最多走k时所能获得的最多苹果数，接下去我们很习惯地会想到将k步在root的所有子结点中分配，也就是进行一次背包，就可以得出此时状态的最优解了，但是这里还有一个问题，那就是在进行背包的时候，对于某个孩子son走完之后是否回到根结点会对后面是否还能分配有影响，为了解决这个问题，我们只需要在状态中增加一维就可以了，用dp[root][k][1]表示在子树root中最多走k步，最后还是回到root处的最大值，dp[root][k][0]表示在子树root中最多走k步，最后不回到root处的最大值。由此可以得到状态转移方程：dp[u][j+2][1] = max(dp[u][j+2][1], dp[u][j-f][1] + dp[v][f][1]);
dp[u][j+1][0] = max(dp[u][j+1][0], dp[u][j-f][1] + dp[v][f][0]);
dp[u][j+2][0] = max(dp[u][j+2][0], dp[u][j-f][0] + dp[v][f][1]);

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 105;

struct Edge{
    int to,next;
}e[maxn<<1];

int dp[maxn][maxn<<1][2], head[maxn], val[maxn], tot, n, k;
//dp[i][j][0]表示从i点出发走j步不返回该点所需要走的步数
//dp[i][j][0]表示从i点出发走j步返回该点所需要走的步数

void addedge(int from,int to){
    e[tot].to = to;
    e[tot].next = head[from];
    head[from] = tot++;
}

void init(){
    tot = 0;
    memset(head, -1, sizeof(head));
    memset(dp, 0, sizeof(dp));
}

void dfs(int u, int fa){
    for(int i = 0; i <= k; i++)
        dp[u][i][0] = dp[u][i][1] = val[u];
    for(int i = head[u]; i != -1; i = e[i].next){
        int v = e[i].to;
        if(v == fa) continue;
        dfs(v, u);
        for(int j = k; j >= 0; j--){  //分组背包的思想，背包容量为k，不明白的可以去看背包九讲，这里是把每一棵子树看做一个背包
            for(int f = 0; f <= j; f++){
                dp[u][j+2][1] = max(dp[u][j+2][1], dp[u][j-f][1] + dp[v][f][1]);
                dp[u][j+1][0] = max(dp[u][j+1][0], dp[u][j-f][1] + dp[v][f][0]);
                dp[u][j+2][0] = max(dp[u][j+2][0], dp[u][j-f][0] + dp[v][f][1]);
            }
        }
    }
}

int main(){
    while(scanf("%d%d", &n, &k) != EOF){
        init();
        for(int i = 1; i <= n; i++) scanf("%d", &val[i]);
        int from, to;
        for(int i = 1; i < n; i++){
            scanf("%d%d", &from, &to);
            addedge(from, to);
            addedge(to, from);
        }
        dfs(1, -1);
        printf("%d\n", max(dp[1][k][0], dp[1][k][1]));
    }
    return 0;
}