算法问题：安慰奶牛

不负韶华ღ

已于 2022-06-21 11:37:53 修改

阅读量170

点赞数

分类专栏：算法文章标签：算法数据结构

于 2022-06-21 10:39:10 首次发布

本文链接：https://blog.csdn.net/weixin_49346755/article/details/125386338

版权

算法专栏收录该内容

22 篇文章 0 订阅

订阅专栏

问题描述

Farmer John变得非常懒，他不想再继续维护供奶牛之间供通行的道路。道路被用来连接N个牧场，牧场被连续地编号为1到N。每一个牧场都是一个奶牛的家。FJ计划除去P条道路中尽可能多的道路，但是还要保持牧场之间的连通性。你首先要决定那些道路是需要保留的N-1条道路。第j条双向道路连接了牧场Sj和Ej(1 <= Sj <= N; 1 <= Ej <= N; Sj != Ej)，而且走完它需要Lj的时间。没有两个牧场是被一条以上的道路所连接。奶牛们非常伤心，因为她们的交通系统被削减了。你需要到每一个奶牛的住处去安慰她们。每次你到达第i个牧场的时候(即使你已经到过)，你必须花去Ci的时间和奶牛交谈。你每个晚上都会在同一个牧场(这是供你选择的)过夜，直到奶牛们都从悲伤中缓过神来。在早上起来和晚上回去睡觉的时候，你都需要和在你睡觉的牧场的奶牛交谈一次。这样你才能完成你的交谈任务。假设Farmer John采纳了你的建议，请计算出使所有奶牛都被安慰的最少时间。

输入格式

第1行包含两个整数N和P。

接下来N行，每行包含一个整数Ci。

接下来P行，每行包含三个整数Sj, Ej和Lj。

输出格式

输出一个整数, 所需要的总时间(包含和在你所在的牧场的奶牛的两次谈话时间)。

样例输入

样例输出

数据规模与约定

5 <= N <= 10000，N-1 <= P <= 100000，0 <= Lj <= 1000，1 <= Ci <= 1,000。

算法思路

问题实际上是一个最小生成树问题，对于最小生成树问题可以采用kruskal算法和prim算法。

采用kruskal算法，在判断是否形成回路时，采用并查算法。具体的算法过程可以参考https://www.cnblogs.com/liuzhen1995/p/6519646.html。

示例代码

1、采用插入排序，只有80分。

import java.util.Scanner;

public class Main {
    static class Edge{
        public int start;
        public int stop;
        public int value;

        public Edge(int start, int stop, int value){
            this.start = start;
            this.stop = stop;
            this.value = value;
        }
    }
    public static int[] values;
    public static Edge[] edges;
    // kruskal最小生成树算法
    public static void getMinTree(){
        int sum = 0;
        int[] id = new int[values.length];
        for(int i = 0; i < values.length; i ++){
            id[i] = -1;
        }
        edgeSort(edges);
        for(int i = 0; i < edges.length; i ++){
            int st = edges[i].start;
            int sp = edges[i].stop;
            int idst = find(id, st);
            int idsp = find(id, sp);
            if(idst != idsp){
                sum += edges[i].value;
                union(id, idst, idsp);
            }
        }
        int minValue = values[0];
        for(int i = 0; i < values.length; i ++){
            if(minValue > values[i]){
                minValue = values[i];
            }
        }
        sum += minValue;
        System.out.println(sum);
    }
    // 插入排序
    public static void edgeSort(Edge[] edges){
        int i, j;
        for(i = 1; i < edges.length ; i ++){
            if(edges[i].value < edges[i - 1].value){
                Edge e = edges[i];
                for(j = i - 1; j >= 0 && edges[j].value > e.value; j --){
                    edges[j + 1] = edges[j];
                }
                edges[j + 1] = e;
            }
        }
    }
    //获取节点a的根节点编号
    public static int find(int[] id, int a) {
        int i, root, k;
        root = a;
        while(id[root] >= 0) 
            root = id[root];  //此处，若id[root] >= 0，说明此时的a不是根节点，因为唯有根节点的值小于0
        k = a;
        while(k != root) {  //将a节点所在树的所有节点，都变成root的直接子节点
            i = id[k];
            id[k] = root;
            k = i;
        }
        return root;
    }
    //判断顶点a和顶点b的根节点大小，根节点值越小，代表其对应树的节点越多，将节点少的树的根节点作为节点多的树的根节点的直接子节点
    public static void union(int[] id, int a, int b) {
        int ida = find(id, a);   //得到顶点a的根节点
        int idb = find(id, b);   //得到顶点b的根节点
        int num = id[ida] + id[idb];  //由于根节点值必定小于0，此处num值必定小于零
        if(id[ida] < id[idb]) {
            id[idb] = ida;    //将顶点b的根节点作为顶点a根节点的直接子节点
            id[ida] = num;   //更新根节点的id值
        } else {
            id[ida] = idb;    //将顶点a的根节点作为顶点b根节点的直接子节点
            id[idb] = num;    //更新根节点的id值
        }
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // n表示顶点数
        int n = scanner.nextInt();
        // p表示边数
        int p = scanner.nextInt();
        // values数组表示每个顶点的值
        values = new int[n];
        // 构建values数组
        for(int i = 0; i < n; i ++){
            values[i] = scanner.nextInt();
        }
        // edges数组表示多条边
        edges = new Edge[p];
        // 构建edges数组
        for(int i = 0; i < p; i ++){
            int start = scanner.nextInt() - 1;
            int stop = scanner.nextInt() - 1;
            int value = scanner.nextInt() * 2 + values[start] + values[stop];
            edges[i] = new Edge(start, stop, value);
        }
        getMinTree();
        scanner.close();
    }
}

在这里插入图片描述

2、采用归并排序，由于归并排序时间复杂度较插入排序少，改进后的代码达到100分。

import java.util.Scanner;

public class Main {
    static class Edge{
        public int start;
        public int stop;
        public int value;

        public Edge(int start, int stop, int value){
            this.start = start;
            this.stop = stop;
            this.value = value;
        }
    }
    public static int[] values;
    public static Edge[] edges;
    // kruskal最小生成树算法
    public static void getMinTree(){
        int sum = 0;
        int[] id = new int[values.length];
        for(int i = 0; i < values.length; i ++){
            id[i] = -1;
        }
        edgeSort(edges);
        for(int i = 0; i < edges.length; i ++){
            int st = edges[i].start;
            int sp = edges[i].stop;
            int idst = find(id, st);
            int idsp = find(id, sp);
            if(idst != idsp){
                sum += edges[i].value;
                union(id, idst, idsp);
            }
        }
        int minValue = values[0];
        for(int i = 0; i < values.length; i ++){
            if(minValue > values[i]){
                minValue = values[i];
            }
        }
        sum += minValue;
        System.out.println(sum);
    }
    // 归并排序
    public static void edgeSort(Edge[] A){
        if(A.length > 1) {
            Edge[] leftA = getHalfEdge(A, 0);
            Edge[] rightA = getHalfEdge(A, 1);
            edgeSort(leftA);
            edgeSort(rightA);
            mergeEdgeArray(A, leftA, rightA);
        }
    }
    //judge = 0返回数组A的左半边元素，否则返回右半边元素
    public static Edge[] getHalfEdge(Edge[] A, int judge) {
        Edge[] half;
        if(judge == 0) {
            half = new Edge[A.length / 2];
            for(int i = 0;i < A.length / 2;i++)
                half[i] = A[i];
        } else {
            half = new Edge[A.length - A.length / 2];
            for(int i = 0;i < A.length - A.length / 2;i++)
                half[i] = A[A.length / 2 + i];
        }
        return half;
    }
    //合并leftA和rightA，并按照从小到大顺序排列
    public static void mergeEdgeArray(Edge[] A, Edge[] leftA, Edge[] rightA) {
        int i = 0;
        int j = 0;
        int len = 0;
        while(i < leftA.length && j < rightA.length) {
            if(leftA[i].value < rightA[j].value) {
                A[len++] = leftA[i++];
            } else {
                A[len++] = rightA[j++];
            }
        }
        while(i < leftA.length) A[len++] = leftA[i++];
        while(j < rightA.length) A[len++] = rightA[j++];
    }
    //获取节点a的根节点编号
    public static int find(int[] id, int a) {
        int i, root, k;
        root = a;
        while(id[root] >= 0) 
            root = id[root];  //此处，若id[root] >= 0，说明此时的a不是根节点，因为唯有根节点的值小于0
        k = a;
        while(k != root) {  //将a节点所在树的所有节点，都变成root的直接子节点
            i = id[k];
            id[k] = root;
            k = i;
        }
        return root;
    }
    //判断顶点a和顶点b的根节点大小，根节点值越小，代表其对应树的节点越多，将节点少的树的根节点作为节点多的树的根节点的直接子节点
    public static void union(int[] id, int a, int b) {
        int ida = find(id, a);   //得到顶点a的根节点
        int idb = find(id, b);   //得到顶点b的根节点
        int num = id[ida] + id[idb];  //由于根节点值必定小于0，此处num值必定小于零
        if(id[ida] < id[idb]) {
            id[idb] = ida;    //将顶点b的根节点作为顶点a根节点的直接子节点
            id[ida] = num;   //更新根节点的id值
        } else {
            id[ida] = idb;    //将顶点a的根节点作为顶点b根节点的直接子节点
            id[idb] = num;    //更新根节点的id值
        }
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // n表示顶点数
        int n = scanner.nextInt();
        // p表示边数
        int p = scanner.nextInt();
        // values数组表示每个顶点的值
        values = new int[n];
        // 构建values数组
        for(int i = 0; i < n; i ++){
            values[i] = scanner.nextInt();
        }
        // edges数组表示多条边
        edges = new Edge[p];
        // 构建edges数组
        for(int i = 0; i < p; i ++){
            int start = scanner.nextInt() - 1;
            int stop = scanner.nextInt() - 1;
            int value = scanner.nextInt() * 2 + values[start] + values[stop];
            edges[i] = new Edge(start, stop, value);
        }
        getMinTree();
        scanner.close();
    }
}

在这里插入图片描述

不负韶华ღ

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
算法问题：安慰奶牛

Farmer John变得非常懒，他不想再继续维护供奶牛之间供通行的道路。道路被用来连接N个牧场，牧场被连续地编号为1到N。每一个牧场都是一个奶牛的家。FJ计划除去P条道路中尽可能多的道路，但是还要保持牧场之间的连通性。你首先要决定那些道路是需要保留的N-1条道路。第j条双向道路连接了牧场Sj和Ej(1 ......
复制链接

扫一扫