蓝桥杯_算法训练_安慰奶牛（用Kruskal、Prim算法分别实现）

最新推荐文章于 2023-04-16 22:53:18 发布
最新推荐文章于 2023-04-16 22:53:18 发布
阅读量694 收藏
点赞数
分类专栏： 蓝桥杯-算法训练 文章标签： 算法 kruskal prim
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huangxiang360729/article/details/50889197
版权

问题描述
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 6
10
10
20
6
30
1 2 5
2 3 5
2 4 12
3 4 17
2 5 15
3 5 6
样例输出
176
数据规模与约定
5 <= N <= 10000，N-1 <= P <= 100000，0 <= Lj <= 1000，1 <= Ci <= 1,000。

Kruskal算法简述:
假设 WN=(V,{E}) 是一个含有 n 个顶点的连通网，则按照克鲁斯卡尔算法构造最小生成树的过程为：
先构造一个只含 n 个顶点，而边集为空的子图，
若将该子图中各个顶点看成是各棵树上的根结点，则它是一个含有 n 棵树的一个森林。
之后，从网的边集 E 中选取一条权值最小的边，若该条边的两个顶点分属不同的树，则将其加入子图，
也就是说，将这两个顶点分别所在的两棵树合成一棵树；反之，若该条边的两个顶点已落在同一棵树上，则不可取，
而应该取下一条权值最小的边再试之。依次类推，直至森林中只有一棵树，也即子图中含有 n-1条边为止。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
import java.util.function.Function;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;

/**
 * @author 翔
 *
 */
public class Main {
    private static int nodeNum;//节点个数
    private static int edgeNum;//边数
    private static int[] C;//节点权值
    private static int Cmin;//最小节点权值
    private static ArrayList<Edge> edges=new ArrayList<Edge>();//边集合
    private static ArrayList<Edge> Enew=new ArrayList<Edge>();//Kruskal算法中的Enew
    private static int[] root;//root[i]:代表i节点所在树对应的根节点
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        init();
        kruskal();
        System.out.println(caculate());
    }

    //计算所需要的总时间
    private static int caculate(){
        int sum=0;
        for(int i=0;i<Enew.size();i++){
            sum+=Enew.get(i).weight;
        }
        return sum+Cmin;
    }

    //Kruskal算法的主要步骤
    private static void kruskal(){
        for(int i=0;i<edges.size()&&Enew.size()<nodeNum-1;i++){
            Edge edge=edges.get(i);
            if(!inSameTree(edge.from,edge.to)){
                Enew.add(edge);
                root[edge.to]=root[edge.from];
            }
        }
    }

    //判断两个顶点是否在同一棵树里
    private static boolean inSameTree(int from,int to){
        if(findRoot(from)==findRoot(to)){
            return true;
        }else{
            return false;
        }
    }

    //寻找某节点的根节点
    private static int findRoot(int i){
        if(root[i]==i){
            return i;
        }else{
            return root[i]=findRoot(root[i]);
        }
    }

    //初始化各参数的值
    private static void init(){
        Scanner sc=new Scanner(System.in);
        nodeNum=sc.nextInt();
        edgeNum=sc.nextInt();
        C=new int[nodeNum+1];
        root=new int[nodeNum+1];
        for(int i=1;i<=nodeNum;i++){
            C[i]=sc.nextInt();
            root[i]=i;
        }
        findCmin();//寻找出最小节点权值
        for(int i=0;i<edgeNum;i++){
            Edge edge=new Edge(sc.nextInt(),sc.nextInt(),sc.nextInt());
            edges.add(edge);
        }

        //重新计算边权!!!!重点！！！！！！！！！！！！
        for(int i=0;i<edgeNum;i++){
            edges.get(i).weight=edges.get(i).weight*2+C[edges.get(i).from]+C[edges.get(i).to];
        }

        Collections.sort(edges,new EdgeComparator());//按照权值对边集合排序
        sc.close();
    }

    //寻找出最小节点权值
    private static void findCmin(){
        int min=C[1];
        for(int i=2;i<=nodeNum;i++){
            if(C[i]<min){
                min=C[i];
            }
        }
        Cmin=min;
    }
}
class Edge{
    int from;
    int to;
    int weight;
    public Edge(int from,int to,int weight){
        this.from=from;
        this.to=to;
        this.weight=weight;
    }
}

class EdgeComparator implements Comparator<Edge>{

    public int compare(Edge arg0, Edge arg1) {
        // TODO Auto-generated method stub
        return arg0.weight-arg1.weight;
    }

    public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
            Function<? super T, ? extends U> arg0) {
        // TODO Auto-generated method stub
        return null;
    }

    public static <T, U> Comparator<T> comparing(
            Function<? super T, ? extends U> arg0, Comparator<? super U> arg1) {
        // TODO Auto-generated method stub
        return null;
    }

    public static <T> Comparator<T> comparingDouble(
            ToDoubleFunction<? super T> arg0) {
        // TODO Auto-generated method stub
        return null;
    }

    public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> arg0) {
        // TODO Auto-generated method stub
        return null;
    }

    public static <T> Comparator<T> comparingLong(ToLongFunction<? super T> arg0) {
        // TODO Auto-generated method stub
        return null;
    }

    public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
        // TODO Auto-generated method stub
        return null;
    }

    public static <T> Comparator<T> nullsFirst(Comparator<? super T> arg0) {
        // TODO Auto-generated method stub
        return null;
    }

    public static <T> Comparator<T> nullsLast(Comparator<? super T> arg0) {
        // TODO Auto-generated method stub
        return null;
    }

    public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
        // TODO Auto-generated method stub
        return null;
    }

    public Comparator<Edge> reversed() {
        // TODO Auto-generated method stub
        return null;
    }

    public Comparator<Edge> thenComparing(Comparator<? super Edge> arg0) {
        // TODO Auto-generated method stub
        return null;
    }

    public <U extends Comparable<? super U>> Comparator<Edge> thenComparing(
            Function<? super Edge, ? extends U> arg0) {
        // TODO Auto-generated method stub
        return null;
    }

    public <U> Comparator<Edge> thenComparing(
            Function<? super Edge, ? extends U> arg0, Comparator<? super U> arg1) {
        // TODO Auto-generated method stub
        return null;
    }

    public Comparator<Edge> thenComparingDouble(
            ToDoubleFunction<? super Edge> arg0) {
        // TODO Auto-generated method stub
        return null;
    }

    public Comparator<Edge> thenComparingInt(ToIntFunction<? super Edge> arg0) {
        // TODO Auto-generated method stub
        return null;
    }

    public Comparator<Edge> thenComparingLong(ToLongFunction<? super Edge> arg0) {
        // TODO Auto-generated method stub
        return null;
    }

}

Prim算法简述
1).输入：一个加权连通图，其中顶点集合为V，边集合为E；
2).初始化：Vnew= {x}，其中x为集合V中的任一节点（起始点），Enew= {},为空；
3).重复下列操作，直到Vnew= V：
a.在集合E中选取权值最小的边

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

/**
 * @author 翔
 *
 */
public class Main {

    private static int nodeNum;//节点个数
    private static int edgeNum;//边数
    private static int[] C;//节点权值
    private static int Cmin;//最小节点权值
    private static ArrayList<Edge> edges=new ArrayList<Edge>();//边集合
    private static ArrayList<Edge> Enew=new ArrayList<Edge>();//Prim算法中的Enew
    private static ArrayList<Integer> V_Vnew=new ArrayList<Integer>();//Prim算法中的V-Vnew
    private static ArrayList<Integer> Vnew=new ArrayList<Integer>();//Prim算法中的Vnew

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        init();
        prim();
        System.out.println(caculate());
    }

    //计算所需要的总时间
    private static int caculate(){
        int sum=0;
        for(int i=0;i<Enew.size();i++){
            sum+=Enew.get(i).weight;
        }
        return sum+Cmin;

    }

    //Prim算法的主要步骤
    private static void prim(){
        for(int i=2;i<=nodeNum;i++){
            int min=Integer.MAX_VALUE;
            Edge temp=null;
            for (int j = 0; j < edges.size(); j++) {
                if (((V_Vnew.contains(edges.get(j).from)
                        && Vnew.contains(edges.get(j).to))
                        || (Vnew.contains(edges.get(j).from)
                        && V_Vnew.contains(edges.get(j).to)))
                        && edges.get(j).weight < min) {
                    temp = edges.get(j);
                    min = temp.weight;
                }
            }
            if(V_Vnew.contains(temp.to)){
                V_Vnew.remove(new Integer(temp.to));
                Vnew.add(temp.to);
            }else{
                V_Vnew.remove(new Integer(temp.from));
                Vnew.add(temp.from);
            }
            edges.remove(temp);
            Enew.add(temp);         
        }   
    }

    //初始化各参数的值
    private static void init(){
        Scanner sc=new Scanner(System.in);
        nodeNum=sc.nextInt();
        edgeNum=sc.nextInt();
        C=new int[nodeNum+1];
        for(int i=1;i<=nodeNum;i++){
            C[i]=sc.nextInt();
            V_Vnew.add(i);
        }
        int CminFlag=findCmin();//寻找出C[]数组中值最小的数对应的下标
        V_Vnew.remove(new Integer(CminFlag));
        Vnew.add(CminFlag);
        for(int i=0;i<edgeNum;i++){
            Edge edge=new Edge(sc.nextInt(),sc.nextInt(),sc.nextInt());
            edges.add(edge);
        }

        //重新计算边权!!!!重点！！！！！！！！！！！！
        for(int i=0;i<edgeNum;i++){
            edges.get(i).weight=edges.get(i).weight*2+C[edges.get(i).from]+C[edges.get(i).to];
        }
        sc.close();
    }

    //寻找出C[]数组中值最小的数对应的下标
    private static int findCmin(){
        int min=C[1];
        int flag=1;
        for(int i=2;i<=nodeNum;i++){
            if(C[i]<min){
                min=C[i];
                flag=i;
            }
        }
        Cmin=min;
        return flag;
    }
}
class Edge{
    int from;
    int to;
    int weight;
    public Edge(int from,int to,int weight){
        this.from=from;
        this.to=to;
        this.weight=weight;
    }
}
huangxiang360729
关注
专栏目录
蓝桥杯-普里姆算法
小赵的呢
03-31 785
普里姆算法应该是贪心算法的一种,具体体现在普里姆算法每一次都是找还最小连通图的最小的一个 import java.util.Arrays; //普里姆算法 public class PrimDemo { public static void main(String[] args) { char[] data = new char[]{'A', 'B', 'C', 'D', 'E', 'F', 'G'}; int verxs = data.length;
蓝桥杯_算法训练 安慰奶牛
A_Bo的博客
03-23 240
问题描述Farmer John变得非常懒，他不想再继续维护供奶牛之间供通行的道路。道路被用来连接N个牧场，牧场被连续地编号为1到N。每一个牧场都是一个奶牛的家。FJ计划除去P条道路中尽可能多的道路，但是还要保持牧场之间 的连通性。你首先要决定那些道路是需要保留的N-1条道路。第j条双向道路连接了牧场Sj和Ej(1 &lt;= Sj &lt;= N; 1 &lt;= Ej &lt;= N; Sj !...
蓝桥杯 安慰奶牛（java）
我的
03-25 546
import java.util.Arrays; import java.util.Scanner; public class Main { static class edge{ int start; int end; int value; edge(int start, int end, int value) { super(); this.start = star...
第十一届蓝桥杯模拟赛第十题（prim算法）
一粒大榴莲的博客
10-14 238
第十题 题目 问题描述 2015年，全中国实现了户户通电。作为一名电力建设者，小明正在帮助一带一路上的国家通电。 　　这一次，小明要帮助 n 个村庄通电，其中 1 号村庄正好可以建立一个发电站，所发的电足够所有村庄使用。 　　现在，这 n 个村庄之间都没有电线相连，小明主要要做的是架设电线连接这些村庄，使得所有村庄都直接或间接的与发电站相通。 　　小明测量了所有村庄的位置（坐标）和高度，如果要连接两个村庄，小明需要花费两个村庄之间的坐标距离加上高度差的平方，形式化描述为坐标为 (x_1, y_1) 高度为
算法训练 安慰奶牛（最小生成树）
逐梦者
03-15 2480
这道关于最小生成树的问题，起初让我百思不得解，所以就搁置了下来，今天才想着做做，一会儿我就跟你们说说我那可笑的理解、可笑的疑惑！ 题目： 问题描述 Farmer John变得非常懒，他不想再继续维护供奶牛之间供通行的道路。道路被用来连接N个牧场，牧场被连续地编号为1到N。每一个牧场都是一个奶牛的家。FJ计划除去P条道路中尽可能多的道路，但是还要保持牧场之间 的连通性。你首先要决定那些道路是需要保留的
java实现 蓝桥杯 算法训练 安慰奶牛
热门推荐
南 墙
07-22 1万+
问题描述 Farmer John变得非常懒，他不想再继续维护供奶牛之间供通行的道路。道路被用来连接N个牧场，牧场被连续地编号为1到N。每一个牧场都是一个奶牛的家。FJ计划除去P条道路中尽可能多的道路，但是还要保持牧场之间 的连通性。你首先要决定那些道路是需要保留的N-1条道路。第j条双向道路连接了牧场Sj和Ej(1 <= Sj <= N; 1 <= Ej <= N; Sj ...
蓝桥杯18年最全算法训练试题181道（含vip试题）
12-04
构造最小生成树可以使用Kruskal算法或Prim算法，本题中可能需要结合贪心思想来优化路径选择，确保访问每个牧场的总时间最少。 7. 逆序对（ALGO-7） 逆序对的计算是排序算法中的一个重要概念，它表示在一个序列中，...
安慰奶牛.zip
12-04
"安慰奶牛.zip"这个压缩包文件包含了与“蓝桥杯VIP题和题解”相关的资源，这通常指的是参与蓝桥杯编程竞赛的选手可能会用到的题目和解答。蓝桥杯是一项全国性的程序设计竞赛，旨在提升大学生的算法设计能力和计算机...
Acwing算法基础课学习笔记
最新发布
togph的博客
04-16 1732
Acwing 算法基础学习笔记
蓝桥杯VIP题目与全套测试数据
12-01
蓝桥杯VIP题目与全套测试数据
图论3-最小生成树
周世正的博客
07-27 296
定义： 生成树：无向图包含所有点的生成子图（即边集包含于原图），且是一棵树。 最小生成树：边权和最小的生成树。 基本性质： 如果把边权看做代价，那么最小生成树就是使全图连通的最小代价。 最小生成树同时满足整棵生成树上的最大边权最小，任意两点间的最大边权最小（这个性质由kruskal算法的执行过程即可得出） 算法： Prim算法 适合处理稠密图，算法复杂度O(n2)O(n^2)O(n2) kruskal算法 适合处理稀疏图，算法复杂度O(mlog⁡m)O(m\log m)O(mlogm)。 另外堆优化Prim
[USACO16DEC]Moocast(gold)奶牛广播-金 题解
hht的博客
02-03 212
题目链接 洛谷P2847 bzoj4744 简化题面 给你n个点，可以在任意两点间连边，代价为两点间的距离。在保证图联通的情况下，最小化最大边权。输出最小的最大边权的平方。 思路 有题解说可以用二分答案，可我不会怎么办？其实并不用二分答案，最小生成树就行，输出最小生成树的最大边权。 证明（自己瞎写的，不一定完善 应该是一定不） 首先，树保证了连通，对于任何一幅图，去掉一些边后变成树，它依然满足条...
安慰奶牛
伍若谷的博客
08-21 189
蓝桥杯试题算法训练安慰奶牛 资源限制 时间限制：1.0s 内存限制：256.0MB 问题描述 Farmer John变得非常懒，他不想再继续维护供奶牛之间供通行的道路。道路被用来连接N个牧场，牧场被连续地编号为1到N。每一个牧场都是一个奶牛的家。FJ计划除去P条道路中尽可能多的道路，但是还要保持牧场之间 的连通性。你首先要决定那些道路是需要保留的N-1条道路。第j条双向道路连接了牧场Sj和Ej(1 <= Sj <= N; 1 <= Ej <= N; Sj != Ej)，而且走完它
安慰奶牛 （最小生成树）
Coldfresh的博客
03-27 532
问题描述 并查集，贪心，最小生成树
算法训练 安慰奶牛
titi2018815的博客
03-13 462
题目： Farmer John变得非常懒，他不想再继续维护供奶牛之间供通行的道路。道路被用来连接N个牧场，牧场被连续地编号为1到N。每一个牧场都是一个奶牛的家。FJ计划除去P条道路中尽可能多的道路，但是还要保持牧场之间 的连通性。你首先要决定那些道路是需要保留的N-1条道路。第j条双向道路连接了牧场Sj和Ej(1 <= Sj<= N; 1 <= Ej<= N; Sj...
蓝桥杯 安慰奶牛Python版
weixin_51040114的博客
04-11 647
马上就要考了，先不说太多，直接贴代码，顺便留着我以后看。 我菜菜，以前是学过C语言的数据结构，和基本的python语言，没学过Python版数据结构。这道题是看网上其他大佬的思路，然后写出来的。所以只过了三个样例，其他7个运行超时[好死亡啊]。。 nodenum,edgenum = map(int,input().split()) vexlist = [] for i in range(nodenum): c = eval(input()) vexlist.append(c) edgelis
算法训练 安慰奶牛(节点有权值的MST)
weixin_30300225的博客
01-22 134
问题描述 Farmer John变得非常懒，他不想再继续维护供奶牛之间供通行的道路。道路被用来连接N个牧场，牧场被连续地编号为1到N。每一个牧场都是一个奶牛的家。FJ计划除去P条道路中尽可能多的道路，但是还要保持牧场之间 的连通性。你首先要决定那些道路是需要保留的N-1条道路。第j条双向道路连接了牧场Sj和Ej(1 <= Sj<= N; 1 <= Ej<= N; ...
蓝桥杯系列3——基础算法
定期分享我的发现和想法，感谢你的陪伴和支持
05-03 4229
蓝桥杯系列3——基础算法 prim算法：最小生成树、动态规划
C语言实现Kruskal与Prim算法
"这篇文档是关于使用C语言实现Kruskal算法和P算法来找到图的最小生成树的源代码示例。Kruskal算法是一种经典的贪心算法，用于解决图论中的最小生成树问题，而P算法在这里可能是Prim算法的误写，通常Prim算法也被用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值