[树上背包] POJ2486 Apple Tree

Apple Tree

题意：

一棵树n(<=100)个节点，每个节点有a[i]个苹果，从1出发走k(<=200)步，问最多能得到多少个苹果。

思路：

首先想到每个节点只有3种情况，要么不经过，要么经过了最后回来，要么经过了最后不回来，只用关心后两种就行。
于是可以想到一个dp[i][j][k]，表示从i出发走j步，k=0表示回来，k=1表示不回来，现在想怎么转移。
转移的关键是每个子节点走多少步，暴力枚举显然是不行的。
不过仔细想想每个子节点都可以0~k-1（要回来就是k-2）步，也就是说要把这k步分配到所有子节点上，可以联想到分组背包，每个节点的0~k-1步为一组，每组内只能选1个，组与组之间没有限制，背包容量是k，然后就可以写出转移了。
对rt的一个子节点v：
枚举剩余容量j：
枚举子节点走的步数l：
$dp[rt][j][0] = max(dp[rt][j][0], dp[rt][j-l][0]+dp[v][l-2][0])$
$dp[rt][j][1] = max(dp[rt][j][1], dp[rt][j-l][0]+dp[v][l-1][1])$
$dprt][j][1] = max(dp[rt][j][1], dp[rt][j-l][1]+dp[v][l-2][0])$
然后就解决了。

//
//  main.cpp
//  2486
//
//  Created by 翅膀 on 16/9/9.
//  Copyright © 2016年 kg20006. All rights reserved.
//
#include <iostream>
#include <stdio.h>
#include <vector>
#include <algorithm>
using namespace std;
const int N = 105;
int a[N], n, k;
vector<int>G[N];
int dp[105][205][2];
void dfs(int rt, int f){
    for(int i = 0; i <= k; ++i) dp[rt][i][0] = dp[rt][i][1] = a[rt];
    for(int i = 0; i < G[rt].size(); ++i){
        int &v = G[rt][i];
        if(v == f) continue;
        dfs(v, rt);
        for(int j = k; j >= 0; --j){
            for(int l = 1; l <= j; ++l){
                if(l >= 2) dp[rt][j][0] = max(dp[rt][j][0], dp[rt][j-l][0]+dp[v][l-2][0]);
                dp[rt][j][1] = max(dp[rt][j][1], dp[rt][j-l][0]+dp[v][l-1][1]);
                if(l >= 2) dp[rt][j][1] = max(dp[rt][j][1], dp[rt][j-l][1]+dp[v][l-2][0]);
            }
        }
    }
}
int main(int argc, const char * argv[]) {
    while(scanf("%d%d", &n, &k) != EOF){
        for(int i = 1; i <= n; ++i) G[i].clear();
        for(int i = 1; i <= n; ++i) scanf("%d", a+i);
        for(int u, v, i = 1; i < n; ++i){
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        dfs(1, 0);
        printf("%d\n", max(dp[1][k][0], dp[1][k][1]));
    }
    return  0;
}