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

最新推荐文章于 2023-03-28 21:11:37 发布
最新推荐文章于 2023-03-28 21:11:37 发布
阅读量709 收藏 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 +
                '}';
    }
}
最小生成树与最短路径
！
02-02 2657
图的最小生成树及最短路径算法详解
贪心算法实现最小生成树
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的一棵最小生成树。
贪心算法之最短路径(Java实现)
11-18
算法分析与设计的实习,用贪心算法实现最短路径,Java的版本,纯属个人原创,非常好用.
最小生成树（prime算法、kruskal算法） 和 最短路径算法（floyd、dijkstra）
weixin_30872671的博客
03-26 457
　　带权图分为有向和无向，无向图的最短路径又叫做最小生成树，有prime算法和kruskal算法；有向图的最短路径算法有dijkstra算法和floyd算法。 　　生成树的概念：联通图G的一个子图如果是一棵包含G的所有顶点的树，则该子图称为G的生成树 生成树是联通图的极小连通子图。所谓极小是指：若在树中任意增加一条边，则 将出现一个回路；若去掉一条边，将会使之编程非连通图。生成树各边的权 值总和...
java单源最短路径（贪心算法）
12-17
java单源最短路径（贪心算法） public class TheShortestWay { static int MAX_SIZE = 6; public static void dijkstra(int v, float[][] a, float[] dist, int[] prev) { int n = dist.length - 1; if (v < 1 || v > n) return; boolean[] s = new boolean[n + 1]; for (int i = 1; i <= n; i++) { dist[i] = a[v][i]; s[i] = false; if (dist[i] == Float.MAX_VALUE) prev[i] = 0; else prev[i] = v;
Java贪心算法 最小生成树 单源最短路径 单机调度问题
11-27
单源最短路径 最小生成树 单机调度问题 三个Java算法
贪心法实现Prim最小生成树（java）
荷塘月色
04-12 715
class TTreeEdge                                                          //用来存储边信息（起始点，终止点，权值）{    float v1,v2;    long weight;}public class Prim {    /**     * @param args the command line arguments     */    public long MinSpanningTree(int[][] g,int n,TT
图论：最短路径+最小生成树+中心度计算
03-22
在本主题中，我们将深入探讨四个关键概念：最短路径算法、最小生成树、中心度计算以及连通分量，这些概念广泛应用于路由、社交网络分析、优化问题等领域。 首先，最短路径问题寻找的是在图中两个节点间路径的最小...
最短路径问题(Dijkstra算法)和最小生成树(Kruskal算法和Prim算法).pdf
02-27
。。。
图算法-最小生成树和单源顶点最短路径
03-21
本主题聚焦于两个核心的图算法：最小生成树（Minimum Spanning Tree, MST）和单源顶点最短路径（Single Source Shortest Path, SSSP）。接下来，我们将深入探讨这两个概念以及如何通过编程实现它们。 最小生成树...
贪心思想和案例(活动安排问题,0-1背包问题,最优装载,哈夫曼编码,单源最短路径,最小生成树(Prim,Kruskal),汽车加油问题).zip
07-03
Dijkstra算法是一种贪心策略，每次扩展当前路径中最短的边，直到到达所有节点。而Floyd-Warshall算法则使用动态规划来求解所有节点对之间的最短路径。 6. **最小生成树**：在加权无向图中找到一棵边的集合，连接...
算法java实现--贪心算法--最小生成树问题--Kruskal算法
qipanliming的专栏
05-14 3826
最小生成树问题（Kruskal算法）的java实现（贪心算法） 具体问题描述以及C/C++实现参见网址 http://blog.csdn.net/liufeng_king/article/details/8738161
贪心算法——最小生成树 Prim算法 Java
m0_45306991的博客
11-25 1477
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].
dijkstra求最小生成树
he1533的博客
03-29 2442
代码：#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)
ale_upcer的博客
03-13 489
#include <iostream> //最下面有数据验证 using namespace std; const int INF=0x3f3f3f3f; int e[100][100]; int dis[1000]; //存储各点到最小生成树的最短距离 int count; int book[1000]; int sum; int main (){ int n,m; cin>>n>>m; int i;int j; for(i=1;i&.
最小生成树——Dijkstra算法
最新发布
qq_54731568的博客
03-28 459
【代码】最小生成树——Dijkstra算法。
贪婪算法在求解最小生成树中的应用（JAVA）--Kruskal算法
一串代码的博客
02-09 799
Kruskal算法又被称为“加边法”，这种算法会将加权连通图的最小生成树看成具有V-1条边的无环子图，且边的权重和最小。算法开始时，会按照权重的非递减顺序对图中的边排序，之后迭代的以贪婪的方式添加边。下面以下图为例来讲解Kruskal算法的过程：Input:6 101 2 31 5 61 6 52 6 52 3 13 6 43 4 64 6 54 5 85 6 2Output:15完整代码如下：i...
Shortcut —— dijkstra求从每个点走都是字典序最小的最小生成树
天翼之城的博客
03-03 426
Description Input Output 输出Farmer John可以达到的总移动时间的最大减少量。 Sample Input 5 6 2 1 2 3 4 5 1 2 5 1 3 3 2 4 3 3 4 5 4 5 2 3 5 7 Sample Output 40 题意： 给你n个点，每个点都有ci头牛，然后给你m条边，每头奶牛都会走最短路到1，如果有多种可能，他们会走从开始位置到1...
透彻_Prim普里姆算法和Dijkstra迪杰斯特拉算法_最小生成树和最短路径
StayAwake
07-29 2086
Prim算法求最小生成树，Dijkstra算法求最短路径。 两者原理和代码结构基本相同，一石二鸟啦。
贪心算法实现最小生成树：Kruskal与Prim源码解析
在给定的文件信息中，“最小生成树_kruskal_matlab_prim_yourselfdeo_最小生成树_源码”这个标题意味着该资源包含了关于最小生成树的Kruskal算法和Prim算法的Matlab实现代码，而标签“kruskal matlab prim ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值