最短路径--------Floyd算法剖析

最新推荐文章于 2024-08-06 17:42:20 发布
最新推荐文章于 2024-08-06 17:42:20 发布
阅读量120 收藏
点赞数
分类专栏： 算法之道 文章标签： 算法 图 最短路径 Floyd

微博：http://weibo.com/375061590

QQ ：375061590

 

用到两个重要矩阵：

 

         1.d[numVex][numVex]  (numVex图的顶点数)：最开始该矩阵就是图的邻接矩阵，经过Floyd算法处理开后，d[numVex][numVex]中的d[i][j]，表示着从顶点i到j的最短路径的权重。

 

         2.p[numVex][numVex]：p[i][j]表示从i到j的最短路径上 i的后继，例如1到5最短路劲为1-2-4-5  那么p[1][5]==2 ，最开始构建的p矩阵中p[i][j]= j

 

算法核心思想：  三圈for循环

 

for (int k = 0; k < graph.getNumVex(); k++) {

 

                     for (int v = 0; v < graph.getNumVex(); v++) {

 

                            for (int w = 0; w < graph.getNumVex(); w++) {

 

                                   if (d[v][w] > d[v][k] + d[k][w]) {

 

                                          d[v][w] = d[v][k] + d[k][w];

 

                                          p[v][w] = p[v][k];// p[v][w]是v--w最短路径上 v的下一顶点

 

                                   }

 

                            }

 

                     }

 

              }

 

第一层 k是作为中间顶点

 

第二层 v是作为起始顶点

 

第三层 w是作为终点顶点

 

 

 

内层核心代码：

 

以v为起点，w为终点，再以k作为v和w之间的中间点，去判断d[v][ w]和d[v][k] + d[k][w]的大小关系，如果d[v][w] > d[v][k] + d[k][w]，说明找到从v→w的更短路径了，此时更改d[v][w]的值为d[v][k] + d[k][w]。

 

 

 

p[v][w]的值也要相应改成p[v][k]的值，因为 p[v][k]的值是v→k最短路径上v的后继顶点，而v→w这段最短路径是连接在v→k这段路径后面的，所以令所当然p[v][w]也要指向p[v][k]。

 

注意：最外层的k循环，前面的n此循环的结果跟后面n+1次循环的错做过程是息息相关，

 

       三次循环完成后，各个顶点之间的最短路径权重会存储在d矩阵中：d[i][j]表示i→j的最短路径权重。

 

p中则存储着路径上的顶点，如果把i→j最短路径上的顶点列出来呢？

代码：

 

//求start→end 最短路径上的顶点

 

StringBuilder path = new StringBuilder();

 

int index = start;//起始点

 

path.append(start + " → ");

 

 

 

              while (index != end) {

 

              //循环取出路径上的各个顶点

 

                     index = p[index][end];

 

                     if(index != end){

 

path.append(index + " →");

 

}

 

                    

 

              }

 

用一个while循环循环 index = p[index][end];直到达到终点

 

假设该最短路径为 start→A→B→C→end

 

则执行过程是：

 

index = p[start][end]; →A

 

path== start→A →

 

 

 

index = p[A][end]; →B

 

path== start→A →B →

 

 

 

index = p[B][end]; →C

 

path== start→A →B →C→

 

 

 

index = p[C][end]; →end

 

path== start→A →B →C→end

 

 

 

这个就是p矩阵的妙处

 

 

 

 

 

 

 

测试：

 

图：



 

 

请输入定点的数目:5
顶点数为：5
请输入边数:7
边数为：7
请输入（Vi，Vj）上下标i 和  j，以及权重，用逗号隔开
0,1,5
0,4,7
1,2,4
4,2,8
1,3,2
2,3,6
4,3,1
初始的d矩阵
 
0 5 9999 9999 7
 
5 0 4 2 9999
 
9999 4 0 6 8
 
9999 2 6 0 1
 
7 9999 8 1 0
 
初始的p矩阵
 
0 1 2 3 4
 
0 1 2 3 4
 
0 1 2 3 4
 
0 1 2 3 4
 
0 1 2 3 4
 
处理后的d矩阵
 
0 5 9 7 7
 
5 0 4 2 3
 
9 4 0 6 7
 
7 2 6 0 1
 
7 3 7 1 0
 
处理后的p矩阵
 
0 1 1 1 4
 
0 1 2 3 3
 
1 1 2 3 3
 
1 1 2 3 4
 
0 3 3 3 4
 
求最短路径
请输入起点：
0
请输入终点：
2
从0到2的最短路径为9
该路劲为：0 → 1 →2
是否继续计算其他最短路径 Y/N?
y
求最短路径
请输入起点：
0
请输入终点：
3
从0到3的最短路径为7
该路劲为：0 → 1 →3
是否继续计算其他最短路径 Y/N?
y
求最短路径
请输入起点：
4
请输入终点：
1
从4到1的最短路径为3
该路劲为：4 → 3 →1
是否继续计算其他最短路径 Y/N?
y
求最短路径
请输入起点：
2
 
请输入终点：
4
从2到4的最短路径为7
该路劲为：2 → 3 →4
是否继续计算其他最短路径 Y/N?

 

源代码：

 

package DataStructure;

import java.util.Scanner;

public class Floyd {
	private Graph graph;
	private int[][] d;// 用来存储顶点到顶点之间最短路径的权重
	private int[][] p;// p[1][5]表示1到5的最短路径上 1的后继，例如1到5最短路劲为1-2-4-5 那么p[1][5]==2

	public Floyd() {
		this.graph = new Graph();
		d = graph.getArc();
		p = new int[graph.getNumVex()][graph.getNumVex()];
		initP();// 初始化矩阵p
		System.out.println("初始的d矩阵\n");
		for (int i = 0; i < graph.getNumVex(); i++) {
			for (int j = 0; j < graph.getNumVex(); j++) {
				System.out.print(d[i][j] + " ");
			}
			System.out.println("\n");
		}
		System.out.println("初始的p矩阵\n");
		for (int i = 0; i < graph.getNumVex(); i++) {
			for (int j = 0; j < graph.getNumVex(); j++) {
				System.out.print(p[i][j] + " ");
			}
			System.out.println("\n");

		}
		work();
		
		System.out.println("处理后的d矩阵\n");
		for (int i = 0; i < graph.getNumVex(); i++) {
			for (int j = 0; j < graph.getNumVex(); j++) {
				System.out.print(d[i][j] + " ");
			}
			System.out.println("\n");
		}
		
		System.out.println("处理后的p矩阵\n");
		for (int i = 0; i < graph.getNumVex(); i++) {
			for (int j = 0; j < graph.getNumVex(); j++) {
				System.out.print(p[i][j] + " ");
			}
			System.out.println("\n");
		}
	}

	/**
	 * 初始化p矩阵
	 * 
	 */
	private void initP() {
		for (int i = 0; i < graph.getNumVex(); i++) {
			for (int j = 0; j < graph.getNumVex(); j++) {
				p[i][j] = j;
			}
		}
	}

	/**
	 * 对d和p进行变化
	 * 
	 */
	private void work() {
		for (int k = 0; k < graph.getNumVex(); k++) {
			for (int v = 0; v < graph.getNumVex(); v++) {
				for (int w = 0; w < graph.getNumVex(); w++) {
					if (d[v][w] > d[v][k] + d[k][w]) {
						d[v][w] = d[v][k] + d[k][w];
						p[v][w] = p[v][k];// p[v][w]是v--w最短路径上 v的下一顶点
					}
				}
			}
		}
	}

	/**
	 * 获取最短路劲
	 * 
	 */
	public void getShortestPath(int start, int end) {
		StringBuilder path = new StringBuilder();
		int index = start;// 起始点
		path.append(start + " → ");

		while (index != end) {
			// 循环取出路径上的各个顶点
			index = p[index][end];
			if (index != end) {
				path.append(index + " →");
			}else {
				path.append(index);
			}

		}

		System.out.println("从" + (start) + "到" + (end) + "的最短路径为"
				+ d[start][end] + "\n该路劲为：" + path.toString());
	}

	public static void getShortestPath(Floyd floyd) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("求最短路径\n请输入起点：");
		int start = scanner.nextInt();
		System.out.println("请输入终点：");
		int end = scanner.nextInt();
		floyd.getShortestPath(start, end);
		System.out.println("是否继续计算其他最短路径 Y/N? ");
		String tag = scanner.next();
		if (tag.toLowerCase().equals("y")) {
			getShortestPath(floyd);
		}

	}

	/**
	 * 图内部类
	 * 
	 * @author ccf
	 * 
	 */
	class Graph {
		/**
		 * 定点数
		 * 
		 */
		private int numVex = 0;
		private int arc[][] = null;
		private int numEdge = 0;
		private final int INFINITY = 9999;

		public Graph() {
			System.out.print("请输入定点的数目:");
			Scanner scanner = new Scanner(System.in);
			this.numVex = scanner.nextInt();
			arc = new int[numVex][numVex];
			for (int i = 0; i < numVex; i++) {
				for (int j = 0; j < numVex; j++) {
					arc[i][j] = INFINITY;
				}
			}
			for (int i = 0; i < numVex; i++) {
				arc[i][i] = 0;

			}
			System.out.println("顶点数为：" + this.numVex);
			System.out.print("请输入边数:");
			scanner = new Scanner(System.in);
			this.numEdge = scanner.nextInt();
			System.out.println("边数为：" + this.numEdge);

			System.out.println("请输入（Vi，Vj）上下标i 和  j，以及权重，用逗号隔开");
			for (int i = 1; i <= numEdge; i++) {
				scanner = new Scanner(System.in);
				String a = scanner.nextLine();
				String[] b = a.split(",");
				// System.out
				// .println("输入了：" + Integer.parseInt(b[0]) + " "
				// + Integer.parseInt(b[1]) + " "
				// + Integer.parseInt(b[2]));
				arc[Integer.parseInt(b[0])][Integer.parseInt(b[1])] = Integer
						.parseInt(b[2]);
				arc[Integer.parseInt(b[1])][Integer.parseInt(b[0])] = Integer
						.parseInt(b[2]);

			}
			
		}

		public int[][] getArc() {
			return arc;
		}

		public int getNumVex() {
			return numVex;
		}

	}

	public static void main(String[] args) {
		Floyd floyd = new Floyd();
		getShortestPath(floyd);
	}

}

 

 

 

chenchuangfeng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多元最短路径——Floyd-Warshall算法
qq2071114140的博客
09-09 1010
多源最短路径——Floyd-Warshall算法 首先分析这张图 就拿从1到3，可以直接1-&gt;3，也可以1-&gt;2-&gt;3,我们发现，通过一个“中转”的2，1-&gt;3路径会变短。 可以在一个路径中插入另一个顶点，这样可能会比直接过去的路径更短，假设每个顶点都经过顶点2中转，可以有这样的语句。 我们用二维数组graph[][]存储图 int i; int j; fo...
最短路径——floyd算法
09-25 753
上一篇博文中讲了Dijkstra算法，这次博文要讲解的是floyd算法，其中Dijkstra算法是属于贪心算法，而floyd算法是动态规划的一个算法： 具体的算法如下： 其中一个矩阵是用来存放最短路径的，另外一个矩阵是用来存放前驱顶点的； #include using namespace std; #define Max 5 #define Infinity 65535 void ma
最短路径-Floyd(弗洛伊德)算法
[SZU_Crayon]
09-01 342
最短路径-Floyd(弗洛伊德)算法 简介： 相较Dijkstra，Floyd是一个完全穷举图中每个点到末尾点的最短路径 算法思想： 按惯例说两个工具 Path[MAX_SIZE][MAX_SIZE]：保存所有的最短路径（指向） Short_Path[MAX_SIZE][MAX_SIZE]：保存所有的最短路径长度（数组） 状态转移： Short_Path[v][w...
每一对顶点之间的最短路径----Floyd算法----（附完整代码）
玥玥的博客博客博客
08-15 2045
1.Floyd算法 2.输出每两对顶点之间的最短距离 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define MaxVertexNum 100 #define INFINITY 65535 //#define MaxSize 10 typedef int Vertex; typedef int WeightType; typede...
Floyd最短路径算法（path矩阵递归实现完整路线）
RockyBlogs
09-24 3290
Floyd最短路径算法（参考王道数据结构书籍思路） Floyd算法的实现思路主要就是简单的动态规划，把一个大的问题化解为一个一个的子问题进行求解，我认为王道的书籍已经讲的足够清晰，所以不做赘述 博文是主要实现王道机构学长所说的path矩阵递归找到完整路径，也是一个很简单递归，主要是将起点和终点之间的其他连接结点找到，所以用递归类似于二分，找到一个中间结点之后再对左右分别进行递归。 本文提供了完整的实现代码，以及两组实验数据用例。（仅初学Floyd算法使用，没有提供优化思路） #include <ios
算法-最短路径-Floyd算法
05-21
**算法-最短路径-Floyd算法** 在计算机科学中，最短路径问题是一个经典的问题，尤其是在图论和网络分析中。Floyd-Warshall算法，通常简称为Floyd算法，是一种用于解决所有对之间最短路径问题的有效算法。由Robert W...
zuiduanlujing.rar_C语言 最短路径_最短路径c-c
09-24
- **Floyd-Warshall算法**：此算法可以找出图中所有节点对之间的最短路径，利用动态规划的思想，通过迭代逐步更新最短路径信息。 - **Bellman-Ford算法**：对于可能存在负权边的情况，Bellman-Ford算法是有效的，...
基于matlab算最短路径--Floyd算法.rar_matlab_
08-10
本文将深入探讨如何使用MATLAB来实现Floyd算法，这是一种经典的解决最短路径问题的算法。 Floyd算法，也称为Floyd-Warshall算法，是由Robert Floyd在1962年提出的。该算法主要用于寻找图中所有顶点之间的最短路径。...
图算法-所有点对最短路径
03-21
这里我们主要讨论的是Floyd算法，也称为Floyd-Warshall算法，它是一种用于解决所有点对最短路径问题的有效方法。 **Floyd算法**由Robert Floyd在1962年提出，其核心思想是利用动态规划来逐步考虑所有可能的中间节点...
最短路径-数据结构课程设计报告.pdf
06-11
这个报告详细介绍了如何构建一个数据结构来存储图，以及如何通过Floyd算法计算最短路径并确定最小偏心度。 1. **问题描述** - 问题设定了一个现实世界的情景，即有n个村庄，需要选择一个地点建立医院，以使其他...
弗洛伊德算法求最短路径
欣淡定的博客
06-06 1712
与迪杰斯特拉算法不同，该算法是一次性将所有顶点到其他顶点的最短路径都求出来，所以需要创建二维数组而不是一位数组 迪杰斯特拉算法求最短路径：https://mp.csdn.net/postedit/91039103 1.首先建立一个二维的邻接矩阵 顶点集合{v0,v1,v2,v3,v4} 边集{（v0,v1,1）,(v1,v2,2),(v2,v3,3),(v3,v4,4),(v4,v0,5)...
最短路径模板+解析——（FLoyd算法）
ytuyzh的博客
03-17 10万+
对于无权的图来说： 若从一顶点到另一顶点存在着一条路径，则称该路径长度为该路径上所经过的边的数目，它等于该路径上的顶点数减1。 由于从一顶点到另一顶点可能存在着多条路径，每条路径上所经过的边数可能不同，即路径长度不同，我们把路径长度最短（即经过的边数最少）的那条路径叫做最短路径，其路径长度叫做最短路径长度或最短距离。 对于带权的图来说： 考虑路径上各边上的权值，则通常把...
最短路径问题---Floyd算法详解
热门推荐
William
03-11 30万+
前言 Genius only means hard-working all one’s life. Name:Willam Time:2017/3/81、最短路径问题介绍问题解释： 从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径，称为最短路径解决问题的算法： 迪杰斯特拉算法（Dijkstra算法） 弗洛伊德算法（Floyd算法） SPFA算法 之前已经对Di
最短路径-Floyd算法的matlab实现.md
kabuto_hui的博客
09-28 5万+
最短路径-Floyd算法的matlab实现 ​ 弗洛伊德算法是解决任意两点间的最短路径的一种算法，可以正确处理有向图或有向图或负权（但不可存在负权回路)的最短路径问题。 ​ 在Floyd算法中一般有两个矩阵，一个距离矩阵D，一个路由矩阵R，其中距离矩阵用于存储任意两点之间的最短距离，而路由矩阵则记录任意两点之间的最短路径信息。 其思想是：如果可以从一个点进行中转，就进行比较从这个点中转和不中转的距...
总结一下最短路径的弗洛伊德算法（Floyd）
riba2534的博客
01-15 9617
看了好多大牛博客，我把弗洛伊德算法在这里总结一下。 弗洛伊德算法的介绍，先参考百度百科：Floyd算法 再来几篇可以参考的博文：http://www.wutianqi.com/?p=1903 http://www.cnblogs.com/biyeymyhjob/archive/2012/07/31/2615833.html ---------------------------------
数据结构——最短路径问题（二）弗洛伊德（Floyd）算法
qazwsxxxxxasd的博客
07-08 400
弗洛伊德（Floyd）算法 算法思路：（学习过程中的个人理解，欢迎指导！） 首先是建图，同时定义两个二维数组，类似于迪杰斯特拉算法中的数组作用，二维数组D代表顶点到顶点的最短路径权值和的矩阵，二维数组P代表对应顶点的最小路径的前驱矩阵 如图，进行初始化后 分别命名为D-1和P-1 接下来是三层循环嵌套，v代表起始顶点，w代表结束顶点，k代表中转顶点的下标 K依次变化，k=0时，代表所有顶点都经过v0中转，此时无任何变化，当k=1时，都经过v1中转此时 D[0][2]=5<D[0][1]+D[1][2
【坐在马桶上看算法】算法6：只有五行的Floyd最短路算法
weixin_30487201的博客
03-25 8581
暑假，小哼准备去一些城市旅游。有些城市之间有公路，有些城市之间则没有，如下图。为了节省经费以及方便计划旅程，小哼希望在出发之前知道任意两个城市之前的最短路程。 上图中有4个城市8条公路，公路上的数字表示这条公路的长短。请注意这些公路是单向的。我们现在需要求任意两个城市之间的最短路程，也就是求任意两个点之间的最短路径。这个问题这也被称为“多源最短路径”...
P1145 约瑟夫
最新发布
zty20120913的博客
08-06 410
n个人站成一圈，从某个人开始数数，每次数到m的人就被杀掉，然后下一个人重新开始数，直到最后只剩一个人。现在有一圈人，k个好人站在一起，k个坏人站在一起。从第一个好人开始数数。你要确定一个最小的m，使得在第一个好人被杀死前，k个坏人先被杀死。
C++初学者指南-5.标准库(第二部分)--数值运算算法
silencestarsky的博客
08-06 927
本文介绍了C++标准库中数值运算的相关算法，重点包括iota、reduce和各种扫描操作（scans），阐述了这些算法的用途、用法及其实现示例，并对并行执行的支持进行了说明。此外，文章还提到了一些遗留操作及其使用场景，为初学者理解C++标准库提供了实用的参考。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值