最短路径

最新推荐文章于 2022-07-22 16:37:00 发布
最新推荐文章于 2022-07-22 16:37:00 发布
阅读量259 收藏
点赞数 1
分类专栏： 啊哈算法 文章标签： 啊哈算法 蓝桥杯 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36496351/article/details/89422749
版权

Floyd-Warshall

问题描述

求任意两个城市之间的最短路径，也就是求任意两点之间的最短路径。这个问题也被称为“多源最短路径”问题。（采用Floyd-Warshall算法）

基本思想：

最开始只允许经过1号顶点进行中转，接下来只允许经过1和2号顶点进行中转......允许经过1~n号顶点进行中转，求任意两点之间的最短路程。本题采用邻接矩阵的方法存储图。

package com.qianwei.chapter6;

import java.util.Scanner;

public class FloydWarshall {

    static int[][] e;
    static int n, m;
    static int inf = 99999999;

    public static void floyd() {
        for (int k = 1; k <= n; k++) {
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= n; j++) {
                    if (e[i][k]<inf && e[k][j]<inf && e[i][j]>e[i][k]+e[k][j]) {
                        e[i][j] = e[i][k] + e[k][j];
                    }
                }
            }
        }
    }
    
    public static void main(String[] args) {
    	Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        e = new int[n+1][n+1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
               if (i == j) 
                   e[i][j] = 0;
               else 
                   e[i][j] = inf;
            }
        }
        for (int i = 1; i <= m; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            int c = sc.nextInt();
            e[a][b] = c;
        }
        floyd();
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) 
                System.out.print(e[i][j] + " ");
            System.out.println();
        }
        sc.close();
    }
}

 

Dijkstra算法——单源最短路

问题描述

就是指定一个点，然后求出这个点到其余各个点的最短路径。

基本思想： 每次找到离源点最近的一个顶点，然后以该顶点为中心进行扩展最终得到源点到其余所有点的最短路径。

基本步骤如下：

  1. 将所有顶点分为两部分：已知最短路程的顶点集合P和未知最短路程的顶点集合Q。用book[i]表示，如果book[i]=1则表示这个顶点在集合P中，反之顶点在集合Q中。
  2. 设置源点s到自己的最短路径为0。其余按照实际情况进行设置。
  3. 在集合Q的所有定点中选择一个离源点s最近的顶点加入到集合P。并考察所有以点u为起点的边，对每一条边进行松弛操作。
  4. 重复第三步，如果集合Q为空，算法结束。最终dis数组中的值就是源点到所有顶点的最短路径。
package com.qianwei.chapter6;

import java.util.Scanner;

public class DijkstraTest1 {

    static int[][] e;
    static int[] book;
    static int[] dis;
    static int n, m;
    static int min;
    static int mark;
    static int inf = 99999999;

    public static void dijkstra() {
        for (int i = 1; i <= n-1; i++) { //循环n-1次，去掉源点
            min = inf;
            for (int j = 1; j <= n; j++) {
                if (book[j] == 0 && dis[j] < min) {
                    min = dis[j];
                    mark = j;
                }
            }
            book[mark] = 1;
            for (int j = 1; j <= n; j++) {
                if (e[mark][j] < inf) {
                    if (dis[j] > dis[mark] + e[mark][j]) 
                        dis[j] = dis[mark] + e[mark][j];
                }
            }
        }
    }
    
    public static void main(String[] args) {
    	Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        e = new int[n+1][n+1];
        dis = new int[n+1];
        book = new int[n+1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
               if (i == j) 
                   e[i][j] = 0;
               else 
                   e[i][j] = inf;
            }
        }
        for (int i = 1; i <= m; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            int c = sc.nextInt();
            e[a][b] = c;
        }
        for (int i = 1; i <= n; i++)
            dis[i] = e[1][i];
        
        book[1] = 1;
        dijkstra();

        for (int i = 1; i <= n; i++)
            System.out.print(dis[i] + " ");
        sc.close();
    }
}

用邻接表来存储图

package com.qianwei.chapter6;

import java.util.Scanner;

public class DijkstraTest2 {

	static int n, m;
	static int[] u;
	static int[] v;
	static int[] w;
	static int[] first;
	static int[] next;
	static int[] dis;
	static int[] book;
	static int inf = 999999999;
	static int mark;
	static int min;
	
	static void dijkstra() {
		for (int i = 1; i <= n-1; i++) { //循环n-1次，去掉源点
            min = inf;
            for (int j = 1; j <= n; j++) {
                if (book[j] == 0 && dis[j] < min) {
                    min = dis[j];
                    mark = j;
                }
            }
            book[mark] = 1;
            for (int j=1;j<=n;j++) {
            	if (mark != j)
            		continue;
            	int k = first[j];
            	while (k != -1) {
            		if (dis[v[k]] > dis[mark] + w[k])
            			dis[v[k]] = dis[mark] + w[k];
            		k = next[k];
            	}
            }
        }
	}
	
	public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        u = new int[m+1];
        v = new int[m+1];
        w = new int[m+1];
        first = new int[n+1];
        next = new int[m+1];
        book = new int[n+1];
        dis = new int[n+1];
        for (int i=1;i<=n;i++)
        	first[i] = -1;
        for (int i=1;i<=m;i++) {
        	u[i] = sc.nextInt();
        	v[i] = sc.nextInt();
        	w[i] = sc.nextInt();
        	next[i] = first[u[i]];
        	first[u[i]] = i;
        }
        for (int i = 1; i <= n; i++)
        	dis[i] = inf;
        dis[1] = 0;
        int k = first[1];
    	while (k != -1) {
    		dis[v[k]] = w[k]; 
    		k = next[k];
    	}        
        book[1] = 1;
        dijkstra();

        for (int i = 1; i <= n; i++)
            System.out.print(dis[i] + " ");
        sc.close();
	}
}

 

Bellman-Ford——解决负权边

package com.qianwei.chapter6;

import java.util.Scanner;

public class BellmanFordTest1 {

	static int[] u;
	static int[] v;
	static int[] w;
	static int[] dis;
    static int n, m;
    static int inf = 999999999;

    static void bellmanFlod() {
        //在一个n个顶点的图中，任意两点之间的最短路径最多包含n-1条边
        for (int k = 1; k <= n - 1; k++) {
            for (int j = 1; j <= m; j++) {
                if (dis[v[j]] > dis[u[j]] + w[j]) {
                    dis[v[j]] = dis[u[j]] + w[j];
                }
            }
        }
    }
    
    public static void main(String[] args) {
    	Scanner sc  = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        u = new int[m+1];
        v = new int[m+1];
        w = new int[m+1];
        dis = new int[n+1];
        for (int i = 1; i <= m; i++) {
            u[i] = sc.nextInt();
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
        }
        for (int i = 1; i <= n; i++) 
            dis[i] = inf;
        dis[1] = 0;
        bellmanFlod();
        for (int i = 1; i <= n; i++) 
            System.out.print(dis[i] + " ");
        sc.close();
    }
}

 

添加检测是否有负权回路功能，再添加一个变量check用来标记数组dis在本轮松弛中是否发生了变化，如果没有发生变化，则可以提前跳出循环。

package com.qianwei.chapter6;

import java.util.Scanner;

public class BellmanFordTest2 {

	static int[] u;
	static int[] v;
	static int[] w;
	static int[] dis;
    static int n, m;
    static int check, flag;
    static int inf = 999999999;

    static void bellmanFlod() {
        //在一个n个顶点的图中，任意两点之间的最短路径最多包含n-1条边
        for (int i = 1; i <= n - 1; i++) {
        	check = 0;
        	for (int j = 1; j <= m; j++) {
                if (dis[v[j]] > dis[u[j]] + w[j]) {
                    dis[v[j]] = dis[u[j]] + w[j];
                    check = 1;
                }
            }
            //松弛完毕后检测数组dis是否有更新
        	//如果数组dis没有更新，提前退出循环结束算法
        	if (check == 0)
        		break;
        }
        //检测负权回路
        flag = 0;
        for (int i = 1; i <= m; i++) {
            if (dis[v[i]] > dis[u[i]] + w[i]) 
                flag = 1;
        }
    }
    
    public static void main(String[] args) {
    	Scanner sc  = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        u = new int[m+1];
        v = new int[m+1];
        w = new int[m+1];
        dis = new int[n+1];
        for (int i = 1; i <= m; i++) {
            u[i] = sc.nextInt();
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
        }
        for (int i = 1; i <= n; i++) 
            dis[i] = inf;
        dis[1] = 0;
        bellmanFlod();
        if (flag == 1) {
            System.out.println("此图含有负权回路");
        } else {
            for (int j = 1; j <= n; j++) {
                System.out.print(dis[j] + " ");
            }
        }
        sc.close();
    }
}

 

Bellman-Ford的队列优化

每次仅对最短路径估计值发生变化了的顶点的所有出边执行松弛操作。

package com.qianwei.chapter6;

import java.util.Deque;
import java.util.LinkedList;
import java.util.Scanner;

public class BellmanFordTest3 {

	static int n, m;
	static int[] u;
	static int[] v;
	static int[] w;
	static int[] first;
	static int[] next;
	static int[] dis;
	static int[] book;
	static int inf = 999999999;
    static Deque<Integer> queue = new LinkedList<Integer>();

    static void bellomanFlod() {
        while (!queue.isEmpty()) {
            int k = first[queue.peek()];
            while (k != -1) {
                if (dis[v[k]] > dis[u[k]] + w[k]) {
                    dis[v[k]] = dis[u[k]] + w[k];
                    if(book[v[k]] == 0) {
                        queue.offer(v[k]);
                        book[v[k]] = 1;
                    }
                }
                k = next[k];
            }
            book[queue.peek()] = 0;
            queue.poll();
        }
    }
    
    public static void main(String[] args) {
    	Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        u = new int[m+1];
        v = new int[m+1];
        w = new int[m+1];
        first = new int[n+1];
        next = new int[m+1];
        book = new int[n+1];
        dis = new int[n+1];
        for (int i = 1; i <= n; i++) 
            dis[i] = inf;
        dis[1] = 0;
        for (int i = 1; i <= n; i++) 
            first[i] = -1;
        for (int i = 1; i <= m; i++) {
            u[i] = sc.nextInt();
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
            next[i] = first[u[i]];
            first[u[i]] = i;
        }
        queue.offer(1);
        book[1] = 1;
        bellomanFlod();
        for (int i = 1; i <= n; i++) 
            System.out.print(dis[i] + " ");
        sc.close();
    }
}

 

_prime
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python实现最短路径的实例方法
01-19
最短路径问题（python实现） 解决最短路径问题：（如下三种算法） （1）迪杰斯特拉算法（Dijkstra算法） （2）弗洛伊德算法（Floyd算法） （3）SPFA算法 第一种算法： Dijkstra算法 广度优先搜索解决赋权有向图或者...
【数据结构算法】图解prime算法和Kruskal算法（最小生成树）
暮色年华的博客
11-25 4855
最小生成树： 带权连接图中最小生成树：含所有顶点（n个）和n-1条边且它们权值之和最小 Prime算法：拉点法 先选一个顶点放入集合U中，然后把U外顶点和U中任一顶点连线权值最小的加入U中，这样每一步加入U的都是权值最小的，所以，得到的是最小生成树 例：求下图的最小生成树 第一步：假设从顶点0开始，把顶点0加入集合U 5到U中顶点权值最小，把5加入U 4到U中顶点权值最小，4加入U 3到U中顶点权值最小，3加入U 2到U中顶点权值最小，2加入U(不包括6，画错了).
最短路算法
Prime me的博客
11-26 92
今天重新学习贪心，对单源最短路径有了新的认知，迪杰斯特拉算法就是我们常用的最短路算法，该算法本质是在贪心的基础上进行的图论延申。 单源最短路径即为从一个点到其他点的最短路。 该算法主要通过以下几步来完成。 1：初始化最短路数组，dis[1]=0,dis[i]=+1000000000; 2:循环n次，每次找出所有点中距离起点最近的那个点，将该点标记后，用该点更新其他的点的最短路距离。 以下即为迪杰斯特拉算法的朴素算法代码模板。 #include<stdio.h> #include<cstri
最小生成树（prime算法、kruskal算法） 最短路径算法（Floyd,bellmen-ford,dijkstra,Spfa)
Tang7O的博客
04-22 835
文章目录最小生成树的概念例题Prime算法Kruskal算法 最小生成树的概念 生成树的概念：联通图G的一个子图如果是一棵包含G的所有顶点的树，则该子图称为G的生成树 生成树是联通图的极小连通子图。所谓极小是指：若在树中任意增加一条边，则 将出现一个回路；若去掉一条边，将会使之编程非连通图。生成树各边的权 值总和称为生成素的权。权最小的生成树称为最小生成树，常用的算法有prime算法和kruska...
LeetCode热题 HOT52-100
nice___amusin的博客
07-22 198
我们进行广度优先搜索时，每次保存上一轮搜索的结果，然后对上一轮已经保存的结果中的每一个字符串尝试所有可能的删除一个括号的方法，然后将保存的结果进行下一轮搜索。所以就比较第k-1个房间的dp值，和第k-2个房间的dp值加上第k个房间的值。两重for循环，第一次for循环是循环nums的每一个i，第二次for循环是循环nums中的每个小于i的所有数j。dp[i，j]的意思是在数组i到j的范围内，k为分割戳点的左右加自身的最大数量。广度优先搜索，每一轮都删除字符串中的1个括号，直到出现合法匹配的字符串为止。...
最小生成树（prime算法、kruskal算法） 和 最短路径算法（floyd、dijkstra）
weixin_30872671的博客
03-26 415
　　带权图分为有向和无向，无向图的最短路径又叫做最小生成树，有prime算法和kruskal算法；有向图的最短路径算法有dijkstra算法和floyd算法。 　　生成树的概念：联通图G的一个子图如果是一棵包含G的所有顶点的树，则该子图称为G的生成树 生成树是联通图的极小连通子图。所谓极小是指：若在树中任意增加一条边，则 将出现一个回路；若去掉一条边，将会使之编程非连通图。生成树各边的权 值总和...
最短路径算法dijkstra的matlab实现_dijkstra_最短路径算法_
10-04
最短路径算法dijkstra的matlab实现
lingo解最短路径问题
08-09
lingo解最短路径问题。城市之间线路及距离已知。从某个城市出发，到达目的城市，通过lingo编程选取最短路径。
最短路径 Dijkstra算法C语言实现
11-13
本设计以VC++6.0作为程序开发环境，C语言作为程序开发语言，详细介绍了最短路径的求解算法及其C语言实现过程。系统主要实现了图的创建、单源点最短路径的计算功能。依照本系统可以解决实际生活中许多路径选择问题，...
基于gdal 最短路径计算
08-31
基于gdal的最短路径计算方式,参考QGIS实现的,cal文件夹是计算类，其他几个文件是ＱGIS封装
Prime算法-最优路径
03-26
①任选一个顶点v1，将其涂红，其余顶点为白点； ②在一个端点为红色、另一个端点为白色的边中，找一条权最小的边涂红，把该边的白端点也涂成红色； ③如此，每次将一条边和一个顶点涂成红色，直到所有顶点都成红色为止，最终的红色边和顶点便是最小生成树。上面的描述就是最小生成树的逐步生长过程
数模经典算法（最短路径）
05-02
利用MATLAB计算最短路径的数模的算法。
【数学建模】最短路径问题
06-27
MATLAB绘制最短路，路径用红色加宽1.5mm
Python基于Floyd算法求解最短路径距离问题实例详解
12-23
本文实例讲述了Python基于Floyd算法求解最短路径距离问题。分享给大家供大家参考，具体如下： Floyd算法和Dijkstra算法，相信大家都不陌生，在最短路径距离的求解中应该算得上是最为基础和经典的两个算法了，今天就...
python Dijkstra算法实现最短路径问题的方法
09-18
主要介绍了python Dijkstra算法实现最短路径问题的方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
最小生成树（prime算法、kruskal算法） 和 最短路径算法（floyd、dijkstra）（转）
笔记
05-31 966
原网址 带权图分为有向和无向，无向图的最短路径又叫做最小生成树，有prime算法和kruskal算法；有向图的最短路径算法有dijkstra算法和floyd算法。　　生成树的概念：联通图G的一个子图如果是一棵包含G的所有顶点的树，则该子图称为G的生成树 生成树是联通图的极小连通子图。所谓极小是指：若在树中任意增加一条边，则 将出现一个回路；若去掉一条边，将会使之编程非连通图。生成树各边的权 值总和
Prime Path——最短路径
weixin_44006014的博客
01-30 1095
Prime Path The ministers of the cabinet were quite upset by the message from the Chief of Security stating that they would all have to change the four-digit room numbers on their offices.  — It is a ...
最小生成树算法（Prime、Kruskal）和最短路径算法（Dijkstra、Floyd）
muzhiai的专栏
03-28 2537
  最小生成树算法（Prime、Kruskal）和最短路径算法（Dijkstra、Floyd） 区别： 最小生成树：整个拓扑图的所有路径之和最小，但不能保证任意两点之间的路径最小。在通信网络设计的时候能够保证最小成本。构造最小生成树一般使用贪心策略，有prime算法和kruskal算法 最短路径：对于拓扑图来说源点和目的点之间经过的边上的权值之和最少的路径。Dij
最小生成树-prime算法
热门推荐
lqcsp的专栏
11-04 3万+
Prime算法的核心步骤是：在带权连通图中V是包含所有顶点的集合， U已经在最小生成树中的节点，从图中任意某一顶点v开始，此时集合U={v}，重复执行下述操作：在所有u∈U,w∈V-U的边(u,w)∈E中找到一条权值最小的边，将(u,w)这条边加入到已找到边的集合，并且将点w加入到集合U中，当U=V时，就找到了这颗最小生成树。        其实，算法的核心步骤就是：在所有u∈U,w∈V-U
nodal 最短路径长度
最新发布
12-17
nodal最短路径长度是指在网络中，从一个节点到另一个节点的最短路径的长度。在一个图或网络中，节点是指连接在一起的对象，而路径是指通过连接边从一个节点到另一个节点的序列。计算节点之间的最短路径长度对于优化...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值