航電 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