HDU 1011 Starship Troopers (树形DP)

http://acm.hdu.edu.cn/showproblem.php?pid=1011&PHPSESSID=nrt5ggjfqbhpk9au99mgcvm226

树形DP

题意：给你一颗树，n个顶点，n-1条边，m个花费，从根(编号1)出发，每个顶点有一定花费也有一定收获，并且经过的边不能再次经过，求最大收获是多少？

典型的树形DP，dp[root][k]表示以root为根的子树花费k得到的最大收获，则转移方程为：

dp[root][k]=max(dp[root][k],dp[root][k-i]+dp[t][i])(t为以root的子节点)

注意特判m=0的情况(直接输出0)

// #pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <cmath>
#include <set>
#include <list>
#include <map>
#include <iterator>
#include <cstdlib>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long LL;
#define ROUND(x) round(x)
#define FLOOR(x) floor(x)
#define CEIL(x) ceil(x)
const int maxn = 110;
const int maxm = 210;
const int inf = 0x3f3f3f3f;
const LL inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double INF = 1e30;
const double eps = 1e-6;
const int P[4] = {0, 0, -1, 1};
const int Q[4] = {1, -1, 0, 0};
const int PP[8] = { -1, -1, -1, 0, 0, 1, 1, 1};
const int QQ[8] = { -1, 0, 1, -1, 1, -1, 0, 1};

struct Edge
{
    int u, v;
    int next;
} edge[maxm];
int head[maxn];
int en;
void addsubedge(int u, int v)
{
    edge[en].u = u;
    edge[en].v = v;
    edge[en].next = head[u];
    head[u] = en++;
}
void addedge(int u, int v)
{
    addsubedge(u, v);
    addsubedge(v, u);
}
struct Node
{
    int n, p;
} node[maxn];
bool vis[maxn];
int dp[maxn][maxn];
int n, m;
void init()
{
    memset(head, -1, sizeof(head));
    en = 0;
    memset(vis, 0, sizeof(vis));
    memset(dp, 0, sizeof(dp));
}
void input()
{
    for (int i = 1; i <= n; i++)
        scanf("%d%d", &node[i].n, &node[i].p);
    for (int i = 0; i < n - 1; i++)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        addedge(u, v);
    }
}
void dfs(int s)
{
    vis[s] = 1;
    int num = ceil((double)node[s].n / 20.0);
    for (int i = num; i <= m; i++)
        dp[s][i] = node[s].p;
    for (int i = head[s]; i != -1; i = edge[i].next)
    {
        int v = edge[i].v;
        if (vis[v]) continue;
        dfs(v);
        for (int j = m; j >= num; j--)
        {
            for (int k = 1; j + k <= m; k++)
            {
                dp[s][j + k] = max(dp[s][j + k], dp[s][j] + dp[v][k]);
            }
        }
    }
}
void debug()
{
    //
}
void solve()
{
    dfs(1);
}
void output()
{
    printf("%d
", dp[1][m]);
}
int main()
{
    // std::ios_base::sync_with_stdio(false);
#ifndef ONLINE_JUDGE
    freopen("in.cpp", "r", stdin);
#endif

    while (~scanf("%d%d", &n, &m))
    {
        if (n == -1 && m == -1) return 0;
        init();
        input();
        if (m == 0)
        {
            puts("0");
            continue;
        }
        solve();
        output();
    }
    return 0;
}