贪心算法：Dijkstra最短路径，Prim最小生成树，Kruskal最小生成树（Java实现）

最新推荐文章于 2023-03-28 21:11:37 发布
最新推荐文章于 2023-03-28 21:11:37 发布
阅读量690 收藏 8
点赞数
分类专栏： 摸鱼
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44777287/article/details/109562288
版权
因为这学期上算法课，因为要准备蓝桥杯国赛，所以复习记录一下几个经典的算法 （T_T）。。。

贪心算法

1.Dijkstra最短路径

import java.util.ArrayList;
import java.util.HashMap;

/**
 *  @author: cuttle
 *  @Date: 2020/11/4 19:34
 *  @Description: 最短路径的Dijkstra算法，贪心法
 */
public class NS_DijkstraSSP {
    private int INF = Integer.MAX_VALUE / 2;
    private int n;//顶点个数
    private String[] node = {"A","B","C","D","E","F","G","H","I","J","K","L","M","N"};//存放顶点
    private int[][] W;//距离矩阵
    private String s;//源点
    private ArrayList<String> S;//最短路径的顶点集合
    private HashMap<String,Integer> d;//源点s到所有顶点的距离
    private ArrayList<String> Q;//基于顶点距离值的最小优先队列
    private HashMap<String,String> prev;//前一个顶点
    public NS_DijkstraSSP(int n,int[][] W,String s){
        this.n = n;
        this.W = W;
        this.s = s;
        S = new ArrayList<>();
        d = new HashMap<>();
        prev = new HashMap<>();
        for(int i = 0;i < n;i++){
            if(node[i].equals(s)){
                d.put(node[i],0);
            }else {
                d.put(node[i],INF);
            }
            prev.put(node[i],s);
        }
        Q = new ArrayList<>();
        Q.add(s);
    }
    public void dijkstra(){
        while (Q.size() != 0){
            String v = getVfromQ();
            S.add(v);
            Q.remove(v);
            traversalU(v);
        }
    }
    public String getVfromQ(){
        //在Q中获取距离值最小的顶点v
        String v = Q.get(0);
        int min = d.get(v);
        for(int i = 0;i < Q.size();i++){
           String ss = Q.get(i);
           int dd = d.get(ss);
           if(dd < min){
               min = dd;
               v = ss;
           }
        }
        return v;
    }
    public void traversalU(String v){
        //对v的各邻居结点u进行遍历
        int i = v.charAt(0) - 'A';
        for(int j = 0;j < n;j++){
            String u = node[j];
            if(!S.contains(u)){
                if(W[i][j] + d.get(v) < d.get(u)){
                    d.put(u,W[i][j] + d.get(v));
                    prev.put(u,v);
                    Q.add(u);
                }
            }
        }
    }
    public void print(){
        for(int i = 0;i < n;i++){
            if(!node[i].equals(s)){
                System.out.print(node[i] + "，" + d.get(node[i])+"：");
                String[] result = new String[n];
                String end = node[i];
                String last = prev.get(end);
                result[n - 1] = end;
                result[n - 2] = last;
                int m = 3;
                while(!last.equals(s)){
                    last = prev.get(last);
                    result[n - m] = last;
                    m++;
                }
                for(int a = 0;a < n;a++){
                    if(result[a] != null){
                        if(a == n-1){
                            System.out.print(result[a]);
                        }else{
                            System.out.print(result[a] + "-");
                        }
                    }
                }
                System.out.println();
            }
        }
    }
    public static void main(String[]args){
        int INF = Integer.MAX_VALUE / 2;
        int n1 = 7;
        int[][] W1 = {
                {0,1,4,INF,INF,INF,INF},
                {1,0,INF,3,6,INF,INF},
                {4,INF,0,2,INF,5,INF},
                {INF,3,2,0,2,4,INF},
                {INF,6,INF,2,0,2,7},
                {INF,INF,5,4,2,0,6},
                {INF,INF,INF,INF,7,6,0}
        };
        String s1 = "A";
        String s2 = "B";
        NS_DijkstraSSP ds = new NS_DijkstraSSP(n1,W1,s2);
        ds.dijkstra();
        ds.print();
    }
}

2.Prim最小生成树

import java.util.ArrayList;
import java.util.HashMap;

/**
 *  @author: cuttle
 *  @Date: 2020/11/4 21:00
 *  @Description: 最小生成树的Prim算法，贪心法
 */
public class NS_PrimMST {
    private int INF = Integer.MAX_VALUE / 2;
    private int n;//顶点个数
    private String[] node = {"A","B","C","D","E","F","G","H","I","J","K","L","M","N"};//存放顶点
    private int[][] W;//距离矩阵
    private String s;//源点
    private ArrayList<String> S;//以s为根的MST的子树集合
    private HashMap<String,Integer> d;//相连边的距离数组
    private ArrayList<String> Q;//S中的顶点与直接相连的S外的集合
    private HashMap<String,String> prev;//前一个顶点
    private int weight;//最小生成树的权重
    public NS_PrimMST(int n,int[][] W,String s){
        this.n = n;
        this.W = W;
        this.s = s;
        S = new ArrayList<>();
        d = new HashMap<>();
        prev = new HashMap<>();
        for(int i = 0;i < n;i++){
            if(node[i].equals(s)){
                d.put(node[i],0);
            }else {
                d.put(node[i],INF);
            }
            prev.put(node[i],s);
        }
        Q = new ArrayList<>();
        Q.add(s);
    }
    public void prim(){
        while (Q.size() != 0){
            String v = getVfromQ();
            S.add(v);
            Q.remove(v);
            traversalU(v);
        }
    }
    public String getVfromQ(){
        //在Q中获取距离值最小的顶点v
        String v = Q.get(0);
        int min = d.get(v);
        for(int i = 0;i < Q.size();i++){
            String ss = Q.get(i);
            int dd = d.get(ss);
            if(dd < min){
                min = dd;
                v = ss;
            }
        }
        return v;
    }
    public void traversalU(String v){
        //对v的各邻居结点u进行遍历
        int i = v.charAt(0) - 'A';
        for(int j = 0;j < n;j++){
            String u = node[j];
            if(!S.contains(u)){
                if(W[i][j]< d.get(u)){
                    d.put(u,W[i][j]);
                    prev.put(u,v);
                    Q.add(u);
                }
            }
        }
    }
    public void print(){
        for(int i = 0;i < n;i++){
            if(!node[i].equals(s)){
                System.out.print(node[i] + "，");
                weight += d.get(node[i]);
                String[] result = new String[n];
                String end = node[i];
                String last = prev.get(end);
                result[n - 1] = end;
                result[n - 2] = last;
                int m = 3;
                while(!last.equals(s)){
                    last = prev.get(last);
                    result[n - m] = last;
                    m++;
                }
                for(int a = 0;a < n;a++){
                    if(result[a] != null){
                        if(a == n-1){
                            System.out.print(result[a]);
                        }else{
                            System.out.print(result[a] + "-");
                        }
                    }
                }
                System.out.println();
            }
        }
        System.out.println(weight);
    }
    public static void main(String[]args){
        int INF = Integer.MAX_VALUE / 2;
        int n1 = 7;
        int[][] W1 = {
                {0,1,4,INF,INF,INF,INF},
                {1,0,2,3,6,4,INF},
                {4,2,0,INF,5,5,INF},
                {INF,3,INF,0,2,INF,INF},
                {INF,6,5,2,0,2,7},
                {INF,4,5,INF,2,0,6},
                {INF,INF,INF,INF,7,6,0}
        };
        String s1 = "A";
        String s2 = "B";
        NS_PrimMST ds = new NS_PrimMST(n1,W1,s2);
        ds.prim();
        ds.print();
    }
}

3.Kruskal算法求最小生成树

import java.util.ArrayList;
import java.util.HashMap;

/**
 *  @author: cuttle
 *  @Date: 2020/11/11 16:32
 *  @Description: 图的最小生成树Kruskal算法
 */
public class NS_KruskalMST {
    private String[] vName = {"A","B","C","D","E","F","G","H","I","J","K","L","M","N"};
    private int vNum;//顶点个数
    private int[][] WMatrix;//权矩阵
    private ArrayList<Edges> edges;//所有的边集合
    private HashMap<Integer,ArrayList<String>> vSet;//点的集合
    private ArrayList<Edges> MST;//最小生成树边的集合
    public NS_KruskalMST(int vNum,int[][] WMatrix,String begin){
        this.vNum = vNum;
        this.WMatrix = WMatrix;
        edges = new ArrayList<>();
        vSet = new HashMap<>();
        MST = new ArrayList<>();
        init();
    }
    public void init(){
        //创建边集合
        for(int i = 0;i < vNum;i++){
            for(int j = i;j < vNum;j++){
                Edges e = new Edges(vName[i],vName[j],WMatrix[i][j]);
                edges.add(e);
            }
        }
        //创建顶点集合
        for(int i = 0;i < vNum;i++){
            ArrayList<String> v = new ArrayList<>();
            v.add(vName[i]);
            vSet.put(i,v);
        }
    }
    public void kruskal(){
        while(MST.size() < vNum - 1){
            //找最小的边
            int min = 0;
            for(int i = 0;i < edges.size();i++){
                if(edges.get(i).getWeight() < edges.get(min).getWeight()){
                    min = i;
                }
            }
            Edges minEdge = edges.get(min);
            edges.remove(min);
            String u = minEdge.getU();
            String v = minEdge.getV();
            if(!isSameSet(u,v)){
                unionSets(u,v);
                MST.add(minEdge);
            }
        }
    }
    public boolean isSameSet(String u,String v){
        int uN = -1;
        int vN = -1;//记录两个顶点在hashMap中的位置
        for(int i = 0;i < vSet.size();i++){
            if(vSet.get(i)!=null && vSet.get(i).contains(u)){
                uN = i;
            }
            if(vSet.get(i)!=null && vSet.get(i).contains(v)){
                vN = i;
            }
        }
        return uN == vN;
    }
    public void unionSets(String u,String v){
        int uN = -1;
        int vN = -1;//记录两个顶点在hashMap中的位置
        for(int i = 0;i < vSet.size();i++){
            ArrayList<String> temp = vSet.get(i);
            if(vSet.get(i)!=null && temp.contains(u)){
                uN = i;
            }
            if(vSet.get(i)!=null && temp.contains(v)){
                vN = i;
            }
        }
        for(int m = vSet.get(vN).size() - 1;m >= 0;m--){
            vSet.get(uN).add(vSet.get(vN).get(m));//合并v和u所在集合集合
            vSet.get(vN).remove(m);
        }
    }
    public void printMST(){
        for (Edges ee:MST
             ) {
            System.out.println(ee.toString());
        }
    }
    public static void main(String[]args){
        int INF = Integer.MAX_VALUE / 2;
        int vNum = 7;
        String begin = "A";
        int[][] WMatrix = {
                {0,1,4,INF,INF,INF,INF},
                {1,0,INF,3,6,INF,INF},
                {4,INF,0,2,INF,5,INF},
                {INF,3,2,0,2,4,INF},
                {INF,6,INF,2,0,2,7},
                {INF,INF,5,4,2,0,6},
                {INF,INF,INF,INF,7,6,0}
        };
        NS_KruskalMST k = new NS_KruskalMST(vNum,WMatrix,begin);
        k.kruskal();
        k.printMST();
    }
}
class Edges{
    private String u;
    private String v;//<u,v>
    private int weight;//权重
    public Edges(String u,String v,int weight){
        this.u = u;
        this.v = v;
        this.weight = weight;
    }
    public String getU(){
        return u;
    }
    public String getV(){
        return v;
    }
    public int getWeight(){ return weight; }

    @Override
    public String toString() {
        return "Edges{" +
                "u='" + u + '\'' +
                ", v='" + v + '\'' +
                ", weight=" + weight +
                '}';
    }
}
cuttleKK
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构18：Prim算法和Dijkstra算法
qq_70132617的博客
06-05 1114
摘要： Prim算法和Dijkstra算法是最小生成树和单源最短路径问题里面两个十分经典的算法，并且在我们计算机行业应用十分广泛，是基础算法。所以我们一定要掌握。代码里面有很详细的注释，如果不能很好的看懂理解的话，建议跟着图多跟踪几遍 ...
Prim算法求最小生成树
遇见生活
10-21 176
#include <cstring> #include <iostream> #include <algorithm> using namespace std; const int N = 510,INF = 0x3f3f3f3f; int n,m; int g[N][N]; // a~b的距离 int dist[N]; // t 到集合的距离 boo...
【图论——第七讲】Pirm算法求最小生成树问题及其堆优化
m0_63233163的博客
07-03 746
最小生成树定义：最小生成树其实是的简称时间复杂度 O(n^2)Prim 算法采用的是一种贪心的策略。（Prim算法和Dijkstra算法思路相似）Prim算法简述实现步骤 例题： 记录最小生成树路径 三、Pirm算法堆优化 时间复杂度O(m∗logn)很少用，时间复杂度高的时候可以考虑kruskal算法，实现简单 堆优化Prim相比于Kruskal难写一些，也没有效率上的优势，所以基本上没人写。 最后 莫言真理无穷尽，寸进自有寸进欢......
最小生成树——Dijkstra算法
最新发布
qq_54731568的博客
03-28 394
【代码】最小生成树——Dijkstra算法。
[总结]单源最短路(朴素Dijkstra)与最小生成树(Prim,Kruskal)
☆迷茫Dog的秘密基地☆
10-28 437
朴素Dijkstra 时间复杂度:O(n2+m) , n表示点数，m表示边数 稠密图???? 存储形式:邻接矩阵 模板:g[x][y]存的是初始化时边权,dist[i]存的是1到i的最短距离,也就是我们的目标 求1 - >n的最短路径 1.初始化距离 dist[1] = 0, d[i] = +∞ 2.for i 1~n: t ←不在集合s中的,距离最近的点 s ←t ...
图算法-最小生成树和单源顶点最短路径
03-21
本主题聚焦于两个核心的图算法：最小生成树（Minimum Spanning Tree, MST）和单源顶点最短路径（Single Source Shortest Path, SSSP）。接下来，我们将深入探讨这两个概念以及如何通过编程实现它们。 最小生成树...
图论：最短路径+最小生成树+中心度计算
03-22
在本主题中，我们将深入探讨四个关键概念：最短路径算法、最小生成树、中心度计算以及连通分量，这些概念广泛应用于路由、社交网络分析、优化问题等领域。 首先，最短路径问题寻找的是在图中两个节点间路径的最小...
最短路径问题(Dijkstra算法)和最小生成树(Kruskal算法和Prim算法).pdf
02-27
。。。
MATLAB源码集锦-最小生成树Kruskal算法代码
02-14
通过这个MATLAB源码集锦，你可以深入理解Kruskal算法的实现细节，并进一步扩展到其他图论问题，如Prim算法、Dijkstra算法等，增强你的图处理和优化能力。同时，学习并实践这样的算法有助于提升编程技巧和解决实际...
图的遍历、最短路径、最小生成树
03-31
图的遍历、最短路径和最小生成树是图论中的经典问题，它们在很多领域如网络设计、路由算法、社交网络分析等都有广泛应用。下面我们将深入探讨这些概念。 首先，**图的遍历** 是指在图中按照特定顺序访问每个顶点的...
贪心算法实现最小生成树
05-12
Prim算法 设G=(V,E)是连通带权图，V={1,2,…,n}。构造G的最小生成树的Prim算法的基本思想是： (1)置S={1} (2)只要S是V的真子集，就作如下的贪心选择 选取满足条件i ∈ S，j ∈ V-S，且c[j]最小的边，将顶点j添加到S中。一直到S=V时为止。 (3)选取到的所有边恰好构成G的一棵最小生成树。
Kruskal算法和prim算法求最小生成树学习小结（JAVA）
04-12
NULL 博文链接：https://128kj.iteye.com/blog/1705936
dijkstra求最小生成树
he1533的博客
03-29 2415
代码：#include<bits\stdc++.h>using namespace std;#define LEN 1002 #define MAX INT_MAX int edge[LEN][LEN];int dijkstra(int n){ /*求最小生成树，edge是一个n*n数组， edge[i][j]表示i，j间的权值。为MAX表示无边。 */ in
【算法与数据结构】——Dijkstra算法，最小生成树
气派飞鹰的博客
08-15 3536
参考博客https://blog.csdn.net/C_eeking/article/details/109722190?spm=1001.2014.3001.5502
统一Prim（最小生成树）和Dijkstra（单源最短路径）代码（Java）
不会近视的小何的博客
04-04 1629
两者都采用到了贪心的策略，并且两个算法都一直维护着一个数组dist （Dijkstra），lowCost（最小生成树） 其中：lowCost[i]表示：当前构建的生成树集合到顶点i的最低代价 dist [i]表示：当前节点k到各个顶点的最短路径 算法思路： 不断从不在当前最优集合中去寻找和当前最优集合的最小代价，通过当前选中的最优决策来不断更新维护该数组（dist，lowCost），直到所有顶点都被标记为止。 —直接上代码看 743. 网络延迟时间(最短路径算法) //Dijkstra算法 :从 k 点出发
最小生成树prim算法（java贪心算法实现)
CX的blogs
06-13 2194
这是我学贪心算法写的prim算法的代码，计算时间为O(n^2),用的是java代码，可以直接运行，献丑一放。import java.util.Scanner; public class minsttree { public static void main(String[] args) { int [][] s=new int[100][100]; int i,j; int co...
贪心算法——最小生成树 Prim算法 Java
m0_45306991的博客
11-25 1442
import java.util.Scanner; public class prim1 { public static void main(String[] args) { int [][] s=new int[100][100]; int i,j; int counter=2,startmin=1000; for( i=0;i<100;i++) { for( j=0;j<100;j++) { if(i==j) { s[i].
java实现普里姆算法—求最短路径
天才来源于积累
11-04 635
import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.StringTokenizer; /**  * 普利姆算法--求最短路径(最小生成树)  * @author Administrator  *  */ public class Prim{ //获取数组中的最小
最小生成树-贪心算法
weixin_43843978的博客
04-03 3878
最小生成树算法和前面学到的dijkstr求最短路径的算法及其相似， 最短路径算法-从原点出发-找到一个距离当前最近的结点（则该节点就是原点到该结点的最短距离）- 我们用这条边去跟新和其他结点的最短距离，下次再从剩下的未访问的结点中去选最小值，依次推倒下去每次找到的最小结点都是离原点最短距离。 **最小生成树算法-prim **(这里我们采用的是避圈法)-先找到离原点最近距离的结点i，再去找该结点到...
图论算法详解：最小生成树与最短路径
"本文主要介绍了图论中的四种经典算法，包括最小生成树算法、最短路径算法、拓扑排序算法和关键路径算法。重点讲解了最小生成树算法，特别是生成树的概念及其在连通无向图和有向图中的应用。生成树不唯一，根据不同...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值