HDOJ 1011 Starship Troopers（树形DP）

题意：

给出一棵树，每个点有权值，要取得这个权值需要代价，通过父亲后才能到达儿子。问能量有限时获得的最大值

思路：

1. 树形DP，要特殊考虑 m = 0 的情况，

2. 注意你走过的所有叶子节点都必须留下一人，但是中间的节点可以不留人，即使叶子bugs为0.但是因为要收割possible，必须有 trooper

3. 用泛化背包优化了半天，无奈水平有限，一直WA，后来想想可能此题确实无法像论文中那样的有依赖背包的优化，因为 m = 0 这个奇葩的存在。

 调试半天虽然优化无果，但是也进一步加深了对于树形动态规划的理解，一些边边角角还是有待于打磨。

 

#include <iostream>

#include <algorithm>

using namespace std;



const int MAXN = 110;



struct edge {

    int v;

    edge* next;

} *V[MAXN], ES[MAXN * 2];



int EC, dp[MAXN][MAXN], B[MAXN], P[MAXN];



void addedge(int u, int v)

{

    ES[++EC].next = V[u];

    V[u] = ES + EC; V[u]->v = v;

}



void initdata(int n)

{

    for (int i = 1; i <= n; ++i)

    {

        scanf("%d %d", &B[i], &P[i]);

        B[i] = (B[i] + 19) / 20;

    }



    EC = 0;

    memset(V, 0, sizeof(V));



    for (int i = 1; i < n; ++i)

    {

        int a, b;

        scanf("%d %d", &a, &b);

        addedge(a, b);

        addedge(b, a);

    }

    memset(dp, 0, sizeof(dp));

}



void treedp(int u, int f, int vol)

{

    if (vol <= 0)

        return ;



    dp[u][B[u]] = P[u];



    for (edge* e = V[u]; e; e = e->next)

    {

        if (e->v == f)

            continue;



        treedp(e->v, u, vol - B[u]);



        for (int i = vol; i >= B[u]; --i)

            for (int j = 0; j <= i - B[u]; ++j)

                dp[u][i] = max(dp[u][i], dp[u][i-j] + dp[e->v][j]);

    }



    if (dp[u][0] > 0)

    {

        dp[u][1] = max(dp[u][0], dp[u][1]);

        dp[u][0] = 0;

    }

}



int main()

{

    int n, m;

    while (scanf("%d %d", &n, &m))

    {

        if (n == -1 && m == -1)

            break ;



        initdata(n);

        treedp(1, 0, m);



        printf("%d\n", dp[1][m]);

    }

    return 0;

}