hihocoder 1055 刷油漆 (树型dp)

时间限制: 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

题目分析：树上背包问题，dp[u][i]表示以u为根的子树选了i个节点的最大值，初始值dp[u][1] = 1

转移方程: dp[u][i] = max(dp[u][i], dp[u][i - j] + dp[v][j])，其中v表示u的孩子节点，枚举i的时候需要逆序，原因类似一维0/1背包

import java.util.*;
import java.io.*;

public class Main {

    static class myScanner {
        BufferedReader br;
        StringTokenizer st;

        public myScanner(InputStream in) {
            br = new BufferedReader(new InputStreamReader(in));
            st = new StringTokenizer("");
        }

        public String nextLine() {
            try {
                return br.readLine();
            } catch (IOException e) {
                return null;
            }
        }

        public boolean hasNext() {
            while (!st.hasMoreTokens()) {
                String s = nextLine();
                if (s == null) {
                    return false;
                }
                st = new StringTokenizer(s);
            }
            return true;
        }

        public String next() {
            hasNext();
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
    }

    public static int n, m;
    public static int[] val;
    public static int cnt = 0;
    public static int[] head;
    public static int[][] dp;

    static class EDGE {
        public int to, nxt;
    }

    public static EDGE[] e;

    static void Add(int u, int v) {
        e[cnt].to = v;
        e[cnt].nxt = head[u];
        head[u] = cnt ++;
    }

    static void DFS(int u, int fa) {
        dp[u][1] = val[u];
        for (int i = head[u]; i != -1; i = e[i].nxt) {
            int v = e[i].to;
            if (v != fa) {
                DFS(v, u);
                for (int j = m; j > 1; j --) {
                    for (int k = 0; k < j; k ++) {
                        dp[u][j] = Math.max(dp[u][j], dp[u][j - k] + dp[v][k]);
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        myScanner in = new myScanner(System.in);
        n = in.nextInt();
        m = in.nextInt();
        val = new int[n + 1];
        head = new int[2 * n + 2];
        e = new EDGE[2 * n + 2];
        dp = new int[n + 1][m + 1];
        for (int i = 0; i < 2 * n + 2; i ++) {
            e[i] = new EDGE();
        }
        Arrays.fill(head, -1);
        for (int i = 1; i <= n; i ++) {
            val[i] = in.nextInt();
            Arrays.fill(dp[i], 0);
        }
        int u, v;
        for (int i = 0; i < n - 1; i ++) {
            u = in.nextInt();
            v = in.nextInt();
            Add(u, v);
            Add(v, u);
        }
        DFS(1, -1);
        System.out.println(dp[1][m]);
    }
}