HDOJ 1011 Starship Troopers(树形DP)

第一道树形DP。。

参考了网上的题解，了解了树形DP与DFS一起用的思路。

题意：bugs 组成了一棵树，你带着士兵从根结点进入，干掉某个结点的 bug 可以得到一定的 brain 。显然每个结点到根结点都有唯一的路径，如果你想干掉某个结点，那么该路径的结点都必须被干掉，给你 m 个士兵，求得到 brain 最多的方案。

dp[i][j] 表示处理到结点 i 剩余 j 个士兵的最优解，本题答案即为 dp[1][m]

转移：对 i 的每个子结点 i0，dp[i][j-k] + dp[i0][k] 可以用来转移。

所以对树进行一次DFS，每遍历完一棵子树就用该子树的结果更新根结点的对应值。

这样是可以得到最优解的，因为假设最优解所在的子树按顺序排好， i 是其中某棵最子树，那么它一定可以由之前的子树得到的最优解转移而来，而之前的最优解已经求完了，所以是可行的。

有些细节见注释。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn = 1000;
int n, m;

int bug[maxn], bri[maxn];
int fr[maxn], to[maxn], head[maxn], next[maxn];
int dp[maxn][maxn];
bool vis[maxn];

void dfs(int cur)
{
    vis[cur] = true;
    for(int i = bug[cur]; i <= m; i++)
        dp[cur][i] = bri[cur];
    for(int i = head[cur]; i != -1; i = next[i]) {
        int tar = to[i];
        if(vis[tar]) continue;
        dfs(tar);
        for(int j = m; j >= bug[cur]; j--) {//更新所有的j
            for(int k = 1; j - k >= bug[cur]; k++)//枚举所有可能的k
            ///k = 0;... WA 因为这样相当于不往子树派兵也有可能得到价值，与题意不符
                if(dp[tar][k])//用子结点更新
                    dp[cur][j] = max(dp[cur][j], dp[cur][j-k] + dp[tar][k]);
        }
    }
}

int main()
{
    while(~scanf("%d%d", &n, &m) && (n != -1 || m != -1)) {
        memset(head, -1, sizeof(head));
        for(int i = 1; i <= n; i++) {
            scanf("%d%d", &bug[i], &bri[i]);
            bug[i] = (bug[i] + 19) / 20;//向上取整
        }
        for(int i = 0; i < (n-1) * 2;) {
            scanf("%d%d", &fr[i], &to[i]);
            fr[i^1] = to[i]; to[i^1] = fr[i];
            for(int j = 0; j < 2; j++, i++) {
                next[i] = head[fr[i]];
                head[fr[i]] = i;
            }
        }
        if(m == 0) {
            printf("0\n");
            continue;
        }
        memset(vis, false, sizeof(vis));
        memset(dp, 0, sizeof(dp));
        dfs(1);
        printf("%d\n", dp[1][m]);
    }

    return 0;
}