问题描述

很多时候，我们所做的DP（Dynamic Programming)通常是基于很简单的数据结构，比如一维数组、二维数组、甚至更高维的数组。今天刷 hihocoder的时候，遇到了一道题，很有意思，是树上的DP。

题目

1055 : 刷油漆

时间限制:10000ms
单点时限:1000ms
内存限制:256MB
描述

上回说到，小Ho有着一棵灰常好玩的树玩具！这棵树玩具是由N个小球和N-1根木棍拼凑而成，这N个小球都被小Ho标上了不同的数字，并且这些数字都是处于1..N的范围之内，每根木棍都连接着两个不同的小球，并且保证任意两个小球间都不存在两条不同的路径可以互相到达。没错，这次说的还是这棵树玩具的故事！

小Ho的树玩具的质量似乎不是很好，短短玩了几个星期，便掉漆了！

“简直是一场噩梦！”小Ho拿着树玩具眼含热泪道。

“这有什么好忧伤的，自己买点油漆刷一刷不就行了？”小Hi表示不能理解。

“还可以这样？”小Ho顿时兴高采烈了起来，立马跑出去买回来了油漆，但是小Ho身上的钱却不够——于是他只买回了有限的油漆，这些油漆最多能给M个结点涂上颜色，这就意味着小Ho不能够将他心爱的树玩具中的每一个结点都涂上油漆！

小Ho低头思索了半天——他既不想只选一部分结点补漆，也不想找小Hi借钱，但是很快，他想出了一个非常棒的主意：将包含1号结点的一部分连通的结点进行涂漆（这里的连通指的是这一些涂漆的结点可以互相到达并且不会经过没有涂漆的结点），然后将剩下的结点拆掉！

那么究竟选择哪些结点进行涂漆呢？小Ho想了想给每个结点都评上了分——他希望最后留下来，也就是涂漆了的那些结点的评分之和可以尽可能的高！

那么，小Ho该如何做呢？

提示一：树上的动态规划？其实老早就接触过了吧！

输入

每个测试点（输入文件）有且仅有一组测试数据。
每组测试数据的第一行为两个整数N、M，意义如前文所述。
每组测试数据的第二行为N个整数，其中第i个整数Vi表示标号为i的结点的评分
每组测试数据的第3~N+1行，每行分别描述一根木棍，其中第i+1行为两个整数Ai，Bi，表示第i根木棍连接的两个小球的编号。
对于100%的数据，满足N<=10^2，1<=Ai<=N, 1<=Bi<=N, 1<=Vi<=10^3, 1<=M<=N
小Hi的Tip：那些用数组存储树边的记得要开两倍大小哦！

输出

对于每组测试数据，输出一个整数Ans，表示使得涂漆结点的评分之和最高可能是多少。
样例输入
10 4
370 328 750 930 604 732 159 167 945 210
1 2
2 3
1 4
1 5
4 6
4 7
4 8
6 9
5 10
样例输出
2977

题目链接：http://hihocoder.com/problemset/problem/1055

题解

#include <iostream>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>

using namespace std;

class Solution {
public:
    vector<int> *adj;
    const static int MAX_N = 100 + 10;
    int N, M, V[MAX_N];
    int f[MAX_N][MAX_N];
    void solve() {
        adj = new vector<int>[MAX_N];
        cin >> N >> M;
        for (int i = 0; i < N; i++) cin >> V[i];
        for (int i = 0; i < N-1; i++) {
            int a, b;
            cin >> a >> b;
            adj[a-1].push_back(b-1);
        }
        compute(0, -1);
        cout << f[0][M] << endl;
    }

    void compute(int rt, int higher_rt) {
        // rt is the root id
        for (int i = adj[rt].size()-1; i>= 0; i--) {
            compute(adj[rt][i], rt);
        }
        compute_f(rt, higher_rt);
    }

    void compute_f(int t, int root) {
        // compute f(t, 1..M), here t belongs to [0..N-1]
        // root denotes the root id, if id == -1, then t is tree root, 
        // otherwise t has a root in the tree
        for (int i = 0; i <= M; i++) f[t][i] = 0;
        f[t][1] = V[t];

        for (int adj_idx = 0; adj_idx < adj[t].size(); adj_idx++) {
            if (root == adj[t][adj_idx]) continue;
            for (int m = M; m >= 2; m--) {
                for (int m_child = 1; m_child < m; m_child++) {
                    int t_child = adj[t][adj_idx];
                    f[t][m] = max( f[t][m], f[t_child][m_child] + f[t][m-m_child]);
                }
            }
        }
    }
};

int main() {
    Solution solution;
    solution.solve();
    return 0;
}