蓝桥杯_算法提高_金属采集(树形动态规划)

问题描述
人类在火星上发现了一种新的金属！这些金属分布在一些奇怪的地方，不妨叫它节点好了。
一些节点之间有道路相连，所有的节点和道路形成了一棵树。
一 共有 n 个节点，这些节点被编号为 1~n 。
人类将 k 个机器人送上了火星，目的是采集这些金属。
这些机器人都被送到了一个指定的着落点， S 号节点。
每个机器人在着落之后，必须沿着道路行走。当机器人到达一个节点时，它会采集这个节点蕴藏的所有金属矿。
当机器人完成自己的任务之后，可以从任意 一个节点返回地球。当然，回到地球的机器人就无法再到火星去了。
我们已经提前测量出了每条道路的信息，包括它的两个端点 x 和 y，以及通过这条道路需要花费的能量 w 。
我们想花费尽量少的能量采集所有节点的金属，这个任务就交给你了。

输入格式
第一行包含三个整数 n, S 和 k ，分别代表节点个数、着落点编号，和机器人个数。
接下来一共 n-1 行，每行描述一条道路。一行含有三个整数 x, y 和 w ，代表在 x 号节点和 y 号节点之间有一条道路，通过需要花费 w 个单位的能量。所有道路都可以双向通行。
输出格式
输出一个整数，代表采集所有节点的金属所需要的最少能量。
样例输入
6 1 3
1 2 1
2 3 1
2 4 1000
2 5 1000
1 6 1000
样例输出
3004
样例说明
所有机器人在 1 号节点着陆。
第一个机器人的行走路径为 1->6 ，在 6 号节点返回地球，花费能量为1000。
第二个机器人的行走路径为 1->2->3->2->4 ，在 4 号节点返回地球，花费能量为1003。
第一个机器人的行走路径为 1->2->5 ，在 5 号节点返回地球，花费能量为1001。
数据规模与约定
本题有10个测试点。
对于测试点 1~2 ， n <= 10 ， k <= 5 。
对于测试点 3 ， n <= 100000 ， k = 1 。
对于测试点 4 ， n <= 1000 ， k = 2 。
对于测试点 5~6 ， n <= 1000 ， k <= 10 。
对于测试点 7~10 ， n <= 100000 ， k <= 10 。
道路的能量 w 均为不超过 1000 的正整数。

解题思路：
dp[root][k]:表示在以root为根的子树中停留k（注意是小写k）个机器人的花费。一定注意是要把一棵子数看作一个整体。很好的树形dp，理解了好久。

(1)一开始，dfs刚到某个节点，如果没有儿子节点的话，那么机器人到此就都可以停了，dp[root][k]为0

(2)如果发现了有一个儿子节点，那么考虑在这个儿子节点停留remain(remain的取值范围为：0,1,…,k)个机器人:
//子树son中没有停留机器人，那么意味全反回，最少是去一个所以最少反回一个
dp[root][k]+=dp[next][0]+cost*2;
for(remain=1;remain<=k;remain++){
//dfs到第一个儿子的时候，由于暂时没发现其余儿子，所以留在root节点的机器人都不会有多余消耗
dp[root][k]=min(dp[root][k],dp[root][k-remain]+dp[next][remain]+remain*cost);　
}

(3)随着dfs的深入，每发现一个新儿子，那么更新时就要用考虑到前面所有儿子的状态进行转移。这是一个渐进的过程。比如，在第二个儿子时，k=1,remain=1 的话，
dp[root][k]=min(dp[root][k],dp[root][k-remain]+dp[next][remain]+remain*cost);
用到的dp[root][k-remain]已经不再是0，因为首先必须把第一个儿子访问过再回到root节点。
所有儿子都dfs过之后，得到的dp[root][m]才不再变化。

java代码：

import java.util.ArrayList;
import java.util.Scanner;

/**
 * @author 翔
 *
 */
public class Main {
    private static int n;//节点个数
    private static int s;//着陆点编号
    private static int K;//机器人总个数
    private static Edge[] edge;//edge[i]:代表第i个节点与其他节点构成的边集
    private static boolean[] hasVisit;//判断某节点是否被访问过（也即判断某节点是否是父节点）
    private static int[][] dp;//dp[p][k]:表示在以p为根的子树中停留k个机器人的花费。把一棵子树看作是一个整体

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        init();
        dfs(s);
        System.out.println(dp[s][K]);

    }

    private static void dfs(int root){
        hasVisit[root]=true;//代表该结点已经被访问过了
        for(int i=0;i<edge[root].ends.size();i++){//i代表代表root节点所连接的第i条边
            int next=edge[root].ends.get(i);//next节点为root节点的第i个子节点 
            int cost=edge[root].weights.get(i);
            if(hasVisit[next]){//如果碰到了父节点
                continue;
            }else{
                dfs(next);//求子节点的dp[next][0]、dp[next][1]、...、dp[next][K];
                for(int k=K;k>=0;k--){//这里要注意不能掉了0的情况
                    dp[root][k]+=dp[next][0]+2*cost;//子树son中没有停留机器人，那么意味全反回，最少是去一个所以最少反回一个
                    for(int remain=1;remain<=k;remain++){
                        int temp=dp[root][k-remain]+dp[next][remain]+remain*cost;//在子树son中停remain个机器人的情况
                        if(temp<dp[root][k]){
                            dp[root][k]=temp;
                        }
                    }
                }
            }
        }   
    }


    //初始化相关的参数（n、s、k、edge、dp、hasVisit）
    private static void init(){
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        s=sc.nextInt();
        K=sc.nextInt();
        edge=new Edge[n+1];
        hasVisit=new boolean[n+1];
        dp=new int[n+1][K+1];
        for(int i=1;i<=n;i++){
            edge[i]=new Edge();
        }
        for(int i=1;i<=n-1;i++){
            int v1=sc.nextInt();
            int v2=sc.nextInt();
            int w=sc.nextInt();

            edge[v1].ends.add(v2);
            edge[v1].weights.add(w);

            edge[v2].ends.add(v1);
            edge[v2].weights.add(w);
        }
        sc.close();
    }
}

class Edge{
    ArrayList<Integer> ends=new ArrayList<Integer>();//某节点所连接的所有节点的集合
    ArrayList<Integer> weights=new ArrayList<Integer>();//对应边的权重
}