航电 1011 树形DP

树形DP

题目：有一个树形的山洞，每个洞有存在bug，经过时，需要留下trooper来战斗，trooper不能往回走。每个trooper能消灭20个bug，给定trooper数量，求能获得brain的最大概率。

由题意知，若要经过子节点，必须经过父节点。

定义dp[i][j]表示用j个trooper来占领已i为根节点的子树的概率最大值。

递归的定义dp[i][j]= max{dp[i][j-k]+dp[v][k],dp[i][j]};

用j个trooper来占领根节点为i的子树可能的取值时用k个trooper来占领根节点为v[i的子节点]的子树加上已(j-k)来占领i之和。

前提是j要大于cost[i]，因为占领v[i的子节点]，必须经过i,所以必须花费cost[i]个trooper。

k表示用来占领根节点为v的子树分配的trooper数量,k<=j-cost[i](原因同上)，再加上剩下j-k位trooper的最大概率。

再与dp[i][j]比较取较大值。

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Scanner;

//AC
public class Main_1011 {
    //dp[0-n][1-m]
    static int[][] dp;
    static int[] cost;
    static int[] brain;
    static ArrayList<Integer>[] adj;
    static int m;

    public static void main(String[] args) throws FileNotFoundException {
        Scanner in = new Scanner(new File("src/input.txt"));
        while (true) {
            int n = in.nextInt();
            m = in.nextInt();
            if(n == -1 && m == -1){
                break;
            }
            dp = new int[n][m + 1];
            cost = new int[n];
            brain = new int[n];
            adj = new ArrayList[n];
            int bug;
            for (int i = 0; i < n; i++) {
                bug = in.nextInt();
                brain[i] = in.nextInt();
                cost[i] = (bug + 19) / 20;
                adj[i] = new ArrayList<>();
            }
            for (int i = 0; i < n - 1; i++) {
                int pre = in.nextInt() - 1;
                int post = in.nextInt() - 1;
                adj[pre].add(post);
                adj[post].add(pre);
            }
            if(m == 0 ){
                System.out.println("0");
                continue;
            }
            dfsDp(0, -1);
            System.out.println(dp[0][m]);
        }

    }
    public static void dfsDp(int p, int pre) {
        for (int i = cost[p]; i <= m; i++) {
            dp[p][i] = brain[p];
        }
        int num = adj[p].size();
        for (int i = 0; i < num; i++) {
            int v = adj[p].get(i);
            if (v == pre) {
                continue;
            }
            dfsDp(v, p);
            //计算子树的最大值，前提条件是一定经过了父节点
            //dp[p][k]表示使用了k位士兵来占领以p为根节点的子树的最大值
            for (int j = m; j >= cost[p]; j--) {
                for (int k = 1; k <= j - cost[p]; k++) {
                    if (dp[p][j] < dp[p][j - k] + dp[v][k]) {
                        dp[p][j] = dp[p][j - k] + dp[v][k];
                    }
                }
            }
        }
    }
}

 

注意m=0的情况和continue的位置对结果的影响。

 

参考：https://blog.csdn.net/lishuhuakai/article/details/9192607#commentsedit