题目地址：【P1273】有线电视网 – 洛谷

题目描述

某收费有线电视网计划转播一场重要的足球比赛。他们的转播网和用户终端构成一棵树状结构，这棵树的根结点位于足球比赛的现场，树叶为各个用户终端，其他中转站为该树的内部节点。
从转播站到转播站以及从转播站到所有用户终端的信号传输费用都是已知的，一场转播的总费用等于传输信号的费用总和。
现在每个用户都准备了一笔费用想观看这场精彩的足球比赛，有线电视网有权决定给哪些用户提供信号而不给哪些用户提供信号。
写一个程序找出一个方案使得有线电视网在不亏本的情况下使观看转播的用户尽可能多。

输入输出格式

输入格式：
输入文件的第一行包含两个用空格隔开的整数N和M，其中2 \leq N \leq 3000，1 \leq M \leq N-1，N为整个有线电视网的结点总数，M为用户终端的数量。
第一个转播站即树的根结点编号为1，其他的转播站编号为2到N-M，用户终端编号为N-M+1到N。
接下来的N-M行每行表示—个转播站的数据，第i+1行表示第i个转播站的数据，其格式如下：

K A1 C1 A2 C2 … Ak Ck

K表示该转播站下接K个结点(转播站或用户)，每个结点对应一对整数A与C，A表示结点编号，C表示从当前转播站传输信号到结点A的费用。最后一行依次表示所有用户为观看比赛而准备支付的钱数。

输出格式：
输出文件仅一行，包含一个整数，表示上述问题所要求的最大用户数。

输入输出样例

输入样例#1：

5 3
2 2 2 5 3
2 3 2 4 3
3 4 2

输出样例#1：

2

说明

样例解释

如图所示，共有五个结点。结点①为根结点，即现场直播站，②为一个中转站，③④⑤为用户端，共M个，编号从N-M+1到N，他们为观看比赛分别准备的钱数为3、4、2，从结点①可以传送信号到结点②，费用为2，也可以传送信号到结点⑤，费用为3（第二行数据所示），从结点②可以传输信号到结点③，费用为2。也可传输信号到结点④，费用为3（第三行数据所示），如果要让所有用户（③④⑤）都能看上比赛，则信号传输的总费用为：2+3+2+3=10，大于用户愿意支付的总费用3+4+2=9，有线电视网就亏本了，而只让③④两个用户看比赛就不亏本了。

解题思路

显然是一个树形DP，但是每个子树怎么处理也就成了问题。对于每一个终端用户，决策是选或不选，可以看成一个树上的01背包，因此设计状态为dp[u][i]表示节点u给i个用户提供服务的利润，转移方程如下
dp[u][i+k] = max\{dp[u][i+k], dp[u][i] + dp[v][k] - w[u][v]\}
其中，v是u的子节点，k是一个枚举的量，表示从子节点选择多少用户提供服务。依照01背包的顺序枚举即可。最后的答案在dp[1][i]中，取dp值非负的i最大值即可。

代码

// Code by KSkun, 2017/12
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>

struct io {
    char buf[1 << 26], *s;

    io() {
        fread(s = buf, 1, 1 << 26, stdin);
    }

    inline int read() {
        register int res = 0;
        while(*s < '0' || *s > '9') s++;
        while(*s >= '0' && *s <= '9') res = res * 10 + *s++ - '0';
        return res;
    }
};

io ip;

#define read ip.read 

struct Edge {
    int to, w;
    Edge(int to, int w): to(to), w(w) {}
};

std::vector<Edge> vec[3005];

inline void addedge(int u, int v, int w) {
    vec[u].push_back(Edge(v, w));
    vec[v].push_back(Edge(u, w));
} 

int n, m, w[3005], kt, at, ct, fa[3005], siz[3005], dp[3005][3005];

inline void dfs(int u) {
    dp[u][0] = 0;
    if(vec[u].size() == 1) {
        siz[u] = 1;
        dp[u][1] = w[u];
        return;
    }
    for(int i = 0; i < vec[u].size(); i++) {
        int v = vec[u][i].to;
        if(v == fa[u]) continue;
        fa[v] = u;
        dfs(v);
        for(int j = siz[u]; j >= 0; j--) {
            for(int k = siz[v]; k >= 0; k--) {
                dp[u][j + k] = std::max(dp[u][j + k], dp[u][j] + dp[v][k] - vec[u][i].w);
            }
        }
        siz[u] += siz[v];
    }
}

int main() {
    memset(dp, 0xc0, sizeof dp);
    n = read();
    m = read();
    for(int i = 1; i <= n - m; i++) {
        kt = read();
        for(int j = 1; j <= kt; j++) {
            at = read();
            ct = read();
            addedge(i, at, ct);
        }
    }
    for(int i = n - m + 1; i <= n; i++) {
        w[i] = read();
    }
    dfs(1);
    for(int i = m; i >= 0; i--) {
        if(dp[1][i] >= 0) {
            printf("%d", i);
            return 0;
        }
    }
    return 0;
}