Floyd算法
Floyd算法(各对顶点之间的最短距离)
Floyd算法（各对顶点之间的最短距离）Floyd算法（各对顶点之间的最短距离）在上篇文章中议论到了如何求算单源最短路径，因此要想求各对顶点之间的距离，只需循环求算n次即可。
还有另外一种办法来求算各对顶点之间的最短距离，就是Floyd算法，因为其算法过程比Dijksa更简单理解，并且代码更简洁，因此当求算各对顶点之间的最短距离常采纳Floyd算法。
一.Floyd算法假设从i到j的最短路径上要经过若干个顶点，这些中间顶点中最大的顶点编号为k，最小的顶点为t，因此要求算dist[i][j]的最小值，那么只需要求算dist[i][s]+dist[s][j](t =s =k)的全部值，并取其中最小者即可。
因此可以设置一个中间顶点k(0 =k n)分离插入到每队顶点(i,j)之中，并更新dist[i][j]的值。
当n个顶点插入到每队顶点之中，求解便结束了。
其实Floyd算法实质上是一个动态规划算法。
代码实现: /*每对顶点之间最短路径Floyd 2011.8.27*/ iludeiostream include stack define M 100define N 100using namespace std;typef struct node{ int matrix[N][M]; //邻接矩阵 int n; //顶点数 int e; //边数 }MGraph; vo FloydPath(MGraph g,intdist[N][M],int path[N][M]){ int i,j,k; for(i=0;i g.n;i++)for(j=0;j g.n;j++) { if(g.matrix[i][j] 0){ dist[i][j]=g.matrix[i][j]; path[i][j]=i; } ee { if(i!=j) { dist[i][j]=INT_MAX; path[i][j]=-1; } else { dist[i][j]=0; path[i][j]=i; } } } for(k=0;k g.n;k++) //中间插入点(注重理解k为什么只能在最外层) for(i=0;i g.n;i++) for(j=0;jg.n;j++) { if((dist[i][k] 0 dist[i][k] INT_MAX) //防止加法溢出 (dist[k][j] 0 dist[k][j] INT_MAX) dist[i][k]+dist[k][j] dist[i][j]) { dist[i][j]=dist[i][k]+dist[k][j];path[i][j]=path[k][j]; //path[i][j]记录从i到j的最短路径上j 的前一个顶点 } } }void showPath(int path[N][M],int s,int t) //打印出最短路径 { stack int st; int v=t; while(t!=s) { st.push(t);第1页共2页。
Floyd算法
Floyd算法Floyd算法是一种经典的图论算法，用于求解带权有向图中任意两个顶点之间的最短路径问题。
该算法由美国数学家罗伯特·弗洛伊德（Robert Floyd）于1962年提出，因此得名为Floyd算法。
Floyd算法是一种动态规划算法，它采用了“分治”的思想，将问题分解为更小的子问题，然后逐步解决子问题，最终得到解决整个问题的结果。
本文将从算法的背景、基本思想、实现方法及优缺点等方面对Floyd 算法进行详细阐述和分析。
一、算法的背景在讲Floyd算法之前，我们先来了解一下最短路径问题。
顾名思义，最短路径问题就是在给定图中找到两个给定节点之间的一条最短路径，也就是路径上各边权值之和最小的路径。
这个问题在现实生活中有很多应用，比如网络路由、地图路径规划、航线安排等等。
在数学和计算机科学领域中，我们可以通过图论的方法来描述和解决这个问题。
一般来说，给定一张带权有向图G=(V, E)，其中V表示节点的集合，E表示边的集合。
每条边E(i,j)的权重为w(i,j)，表示从节点i到节点j的距离或成本。
那么最短路径问题就是在图中找到从节点s到节点t的一条最短路径P，并且P上的边权之和最小。
最初求解的思路是按照类似深度优先搜索的方式，逐个遍历所有路径，然后依次比较它们的距离，找到最短路径。
但这种方式显然是不可行的，因为它的时间复杂度非常高。
所以，我们需要设计一种更高效的算法，以求得最短路径问题的最优解。
二、算法的基本思想Floyd算法就是一种高效地解决最短路径问题的方法。
它采用了“动态规划”的思想，通过逐步求解子问题，最终得到完整的最短路径。
而解决子问题的方式则是采用了“分治”的思想，将问题分解为更小的子问题，然后逐步解决。
具体地说，Floyd算法采用了“中转节点”的概念，我们可以将问题转化为这样一个子问题：对于每个节点i和节点j，假设我们已经知道了它们之间的最短路径长度为d[i][j]，那么考虑一下节点k作为中转节点，它可以为i和j之间的路径P提供一个“中转服务”，将P拆分为两条路径：i-->k和k-->j。
佛洛伊德算法
佛洛伊德算法一、佛洛伊德算法简介佛洛伊德算法（Floyd Algorithm），又称弗洛伊德算法，是一种用于寻找加权图中所有顶点之间最短路径的算法。
该算法由英国计算机科学家David Floyd于1967年提出，主要用于解决带权有向图和带权无向图中的最短路径问题。
二、佛洛伊德算法与最短路径算法的关系佛洛伊德算法与最短路径算法密切相关，但它不同于Dijkstra算法和Bellman-Ford算法。
后两种算法主要用于求解单源最短路径，而佛洛伊德算法可以同时求解图中所有顶点之间的最短路径。
三、佛洛伊德算法的基本原理1.假设图中所有顶点已按照某种顺序编号，边的权值均为非负数。
2.初始化一个距离矩阵，将矩阵中所有元素设为无穷大（表示尚未确定最短路径）。
3.对于每个顶点k，遍历图中的所有顶点i和j，尝试将顶点k作为其他两点之间的中间点，更新距离矩阵中的距离值。
4.重复步骤3，直到所有顶点之间的最短路径都被求解出来。
四、佛洛伊德算法的应用场景1.带权有向图和带权无向图的最短路径问题。
2.网络路由规划：在计算机网络中，用于寻找最优路径，提高数据传输效率。
3.物流配送：在物流领域，用于优化配送路线，降低运输成本。
五、佛洛伊德算法的优缺点优点：1.可以同时求解图中所有顶点之间的最短路径。
2.算法稳定性较好，适用于大规模图计算。
缺点：1.计算复杂度高，时间复杂度为O(nm)，其中n为顶点数，m为边数。
2.空间复杂度较高，需要存储整个距离矩阵。
六、佛洛伊德算法在现实生活中的应用案例1.地图导航：利用佛洛伊德算法计算出行路线，为用户提供最优路径。
2.物流配送：通过佛洛伊德算法优化配送路线，提高物流效率。
简介Floyd算法
简介Floyd 算法⽬录1. 定义Floyd 算法是⼀种⽤于寻找给定的加权图中顶点间最短路径，是经典的多源最短路径算法，可以有效地处理有向图或负权的最短路径问题，同时也被⽤于计算有向图的传递闭包。
Floyd 算法的时间复杂度为 O (N 3)，空间复杂度为 O (N 2)。
2. 优缺点优点：容易理解，可以算出任意两个节点之间的最短距离，代码编写简单。
缺点：时间复杂度⽐较⾼，不是和计算⼤量数据。
3. 基本思想Floyd 算法属于动态规划算法，即寻找节点 i 到节点 j 的最短路径。
Step 1: 初始距离定义 n 节点⽹络的邻接矩阵 A n ×n ，矩阵中的元素为 a i ,j 为节点 i 到节点 j 的⼀步的直线距离。
令 A (0)=A ，其初始元素为 a (0)i ,j 则该距离有如下三种情况：a (0)i ,j =c i ,j , i ,j 相连0, i =j∞, i ,j 不相连其中，节点 i , j 之间有直线连接时，则 a (0)i ,j 为其距离值 c i ,j ；节点 i 到⾃⾝的距离为 0；节点 i , j 之间没有直线连接时，则 a (0)i ,j 则为 ∞，如下图：则该初始邻接矩阵 A 为：即节点0与节点0⾃⾝距离值为0，即 A [0][0]=0；节点0与节点1之间有直线连接，距离值为5，即 A [0][1]=5；节点0与节点2之间没有直线连接，则距离值为 ∞，即 A [0][2]=∞；节点0与节点3之间有直线连接，距离值为7，即 A [0][3]=7 ……其他节点间的初始距离可依次写出，即为该邻接矩阵 A 。
Step 2: 借中转节点迭代找最短路径节点 i , j 间⼀步达不到时，则需要在两节点之间通过其他节点（如节点 k ）作连接：在 A 矩阵上做 n 次迭代，k =1,⋯,n ，第 k 次迭代a k i ,j =min (a k −1i ,j ,a k −1i ,k +a k −1k ,j )即在节点 i 和节点 j 之间找到⼀条最短距离的路径，如下图：图中的节点 i 到节点 j 之间的直线距离 (i →j ) 为 6，但经过节点 k 作中转后，节点 i 到节点 j 之间的直线距离 (i →k →j ) 为 2+3=5，因此 a k i ,j =min (6,5)=5。
Floyd算法简介
Floyd算法简介⼀.Floyd算法的介绍1.算法的特点：弗洛伊德算法是解决任意两点间的最短路径的⼀种算法，可以正确处理⽆向图或有向图或负权（仅适合权值⾮负的图)的最短路径问题，同时也被⽤于计算有向图的传递闭包。
2.算法的思路： 通过Floyd计算图G=(V,E)中各个顶点的最短路径时，需要引⼊两个矩阵，矩阵S中的元素a[i][j]表⽰顶点i(第i个顶点)到顶点j(第j个顶点)的距离。
矩阵P（记录最短路的路径需要，若题⽬不需要求路径则不需要P数组）中的元素b[i][j]，表⽰顶点i到顶点j经过了顶点b[i][j]。
假设图G中顶点个数为N，则需要对矩阵D和矩阵P进⾏N次更新。
初始时，矩阵D中顶点a[i][j]的距离为顶点i到顶点j的权值；如果i和j不相邻，则a[i][j]=∞，矩阵P的值为顶点b[i][j]的j的值。
接下来开始，对矩阵D进⾏N次更新。
第1次更新时，如果”a[i][j]的距离” > “a[i][0]+a[0] [j]”(a[i][0]+a[0][j]表⽰”i与j之间经过第1个顶点的距离”)，则更新a[i][j]为”a[i][0]+a[0][j]”,更新b[i][j]=b[i][0]。
同理，第k次更新时，如果”a[i][j]的距离” > “a[i][k-1]+a[k-1][j]”，则更新a[i][j]为”a[i][k-1]+a[k-1][j]”,b[i][j]=b[i][k-1]。
实质上是背包DP问题，最外层循环是k，表⽰利⽤前k个作为中间计算a[i][j]的最⼩值，本来需要三位数组a[k][i][j]，因为第k次循环只会⽤到a[k-1][i][j]，所以利⽤滚动数组，使⽤⼆维数组即可。
更新N次之后，操作完成！时间复杂度为O(N^3)，空间复杂度为O(N^2)。
核⼼代码：1for(k=0;k<n;k++)2for(i=0;i<n;i++)3for(j=0;j<n;j++)4if(a[i][j]>a[i][k]+a[k][j])5 a[i][j]=a[i][k]+a[k][j],b[i][j]=b[i][k]; 只有5⾏！现在你会发现这个看起来很⾼⼤上的算法很简单了，算是最短路的4个算法⾥最暴⼒的了！ 3.实例： 题意：有n种动物，m种直接转换的咒语，且转换具有传递性，求从哪⼀种动物到另⼀种的动物的最长咒语的最⼩值，若不能转换到所有动物，则输出0. 思路：Floyd算法的裸应⽤，将动物抽象为点，咒语长度抽象为边的权值，代码如下：#include<bits/stdc++.h>using namespace std;const int inf=0x3f3f3f3f;int n,m,a,b,c;int mp[105][105];int main(){scanf("%d%d",&n,&m);for(int i=1;i<=n;++i)for(int j=1;j<=n;++j)if(i!=j) mp[i][j]=inf;while(m--){scanf("%d%d%d",&a,&b,&c);mp[a][b]=c;mp[b][a]=c;}for(int k=1;k<=n;++k)for(int i=1;i<=n;++i)for(int j=1;j<=n;++j)if(mp[i][j]>mp[i][k]+mp[k][j])mp[i][j]=mp[i][k]+mp[k][j];int maxi,minv=0,res=inf;for(int i=1;i<=n;++i){maxi=0;for(int j=1;j<=n;++j)if(mp[i][j]>maxi)maxi=mp[i][j];if(maxi<res)res=maxi,minv=i;}if(minv)printf("%d %d\n",minv,res);elseprintf("0\n");return0;}。
floyd算法
Floyd算法正如我们所知道的，Floyd算法用于求最短路径。
Floyd算法可以说是Warshall算法的扩展，三个for循环就可以解决问题，所以它的时间复杂度为O(n^3)。
Floyd算法的基本思想如下：从任意节点A到任意节点B的最短路径不外乎2种可能，1是直接从A到B，2是从A 经过若干个节点X到B。
所以，我们假设Dis(AB)为节点A到节点B的最短路径的距离，对于每一个节点X，我们检查Dis(AX) + Dis(XB) < Dis(AB)是否成立，如果成立，证明从A到X再到B的路径比A直接到B的路径短，我们便设置Dis(AB) = Dis(AX) + Dis(XB)，这样一来，当我们遍历完所有节点X，Dis(AB)中记录的便是A到B的最短路径的距离。
很简单吧，代码看起来可能像下面这样：?但是这里我们要注意循环的嵌套顺序，如果把检查所有节点X放在最内层，那么结果将是不正确的，为什么呢？因为这样便过早的把i到j的最短路径确定下来了，而当后面存在更短的路径时，已经不再会更新了。
让我们来看一个例子，看下图：图中红色的数字代表边的权重。
如果我们在最内层检查所有节点X，那么对于A->B，我们只能发现一条路径，就是A->B，路径距离为9。
而这显然是不正确的，真实的最短路径是A->D->C->B，路径距离为6。
造成错误的原因就是我们把检查所有节点X放在最内层，造成过早的把A到B的最短路径确定下来了，当确定A->B的最短路径时Dis(AC)尚未被计算。
所以，我们需要改写循环顺序，如下：?这样一来，对于每一个节点X，我们都会把所有的i到j处理完毕后才继续检查下一个节点。
那么接下来的问题就是，我们如何找出最短路径呢？这里需要借助一个辅助数组Path，它是这样使用的：Path(AB)的值如果为P，则表示A节点到B节点的最短路径是A->...->P->B。
弗洛伊德（Floyd）算法
弗洛伊德（Floyd）算法最短路径问题：从某个顶点出发到达另外⼀个顶点的所经过的边的权重和最⼩的⼀条路径弗洛伊德算法解决最短路径问题1.基本思想（1）计算图中各个顶点之间的最短路径，每⼀个顶点都是出发访问点，所以需要将每⼀个顶点看做被访问顶点，求出从每⼀个顶点到其他顶点的最短路径（2）所有顶点都作为中间节点遍历⼀次，每次遍历将各个顶点经过中间节点到另⼀个节点的距离，与不经过该节点的距离相⽐较，若经过中间节点的距离更⼩，就更新距离表与前驱关系（3）时间复杂度O(n3)，所有顶点作为出发点、中间节点、终点，每个顶点都要遍历3次2.步骤（1）设置顶点 a 到顶点 b 的最短路径已知为 L ab，顶点 b 到 c 的最短路径已知为 L bc，顶点 a 到 c 的路径为 L ac，则 a 到 c 的最短路径为：min ( ( L ab + L bc ), L ac )，b 的取值为图中所有顶点，则可获得 a 到 b 的最短路径（2）⾄于 a 到 b 的最短路径 L ab或者 b 到 c 的最短路径 L bc，是以同样的⽅式获得（3）三个点为同⼀顶点时：中间顶点为⾃⾝；三个点是不同顶点时：中间顶点是终点的前驱节点；两个顶点直接连通时：中间节点为出发点代码实现import java.util.Arrays;public class Floyd {//弗洛伊德算法解决最短路径问题public static final int BLOCK = 65535;//表⽰顶点之间不直接连通public static void main(String[] args) {char[] vertex = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};//顶点到⾃⾝距离为0int[][] matrix = {{0, 5, 7, BLOCK, BLOCK, BLOCK, 2},{5, 0, BLOCK, 9, BLOCK, BLOCK, 3},{7, BLOCK, 0, BLOCK, 8, BLOCK, BLOCK},{BLOCK, 9, BLOCK, 0, BLOCK, 4, BLOCK},{BLOCK, BLOCK, 8, BLOCK, 0, 5, 4},{BLOCK, BLOCK, BLOCK, 4, 5, 0, 6},{2, 3, BLOCK, BLOCK, 4, 6, 0}};Graph graph = new Graph(matrix, vertex);graph.floyd();graph.result();}}//带权⽆向图class Graph {public char[] vertex;//存放顶点public int[][] matrix;//保存各个顶点到其它顶点的距离，初始为直接连接的距离，算法计算后为最短距离public int[][] relay;//保存中间结点//构造器public Graph(int[][] matrix, char[] vertex) {this.vertex = vertex;this.matrix = matrix;this.relay = new int[vertex.length][vertex.length];//三个点为同⼀顶点时：中间顶点为⾃⾝；三个点是不同顶点时：中间顶点是终点的前驱节点；两个顶点直接连通时：中间节点为出发点for (int i = 0; i < vertex.length; i++) {Arrays.fill(relay[i], i);//初始中间顶点为⾃⾝}}//显⽰算法结果public void result() {for (int k = 0; k < vertex.length; k++) {for (int i = 0; i < vertex.length; i++) {System.out.println(vertex[k] + " 到 " + vertex[i] +" 最短路径 " + matrix[k][i] +" 中间结点 " + vertex[relay[k][i]]);}System.out.println();}}//弗洛伊德算法public void floyd() {int temp;//保存i到j的距离for (int i = 0; i < matrix.length; i++) {//出发点ifor (int j = 0; j < matrix.length; j++) {//中间顶点jfor (int k = 0; k < matrix.length; k++) {//终点ktemp = matrix[i][j] + matrix[j][k];//求从i出发，经过k，到达j的距离 if (temp < matrix[i][k]) {matrix[i][k] = temp;//更新距离relay[i][k] = relay[j][k];//更新中间顶点}}}}}}。
Floyd算法详解
Floyd算法详解Floyd-WarshallFloyd算法，是⼀种著名的多源最短路算法。
核⼼思想：⽤邻接矩阵存储图，核⼼代码为三重循环，第⼀层枚举中间点k，⼆三层分别枚举起始点i与⽬标点j。
然后判断经过中间点k后，i与j间的路程是否会减⼩。
如果是，就更新i，j之间的最短路。
for(int k=1;k<=n;k++)for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)if(e[i][j]>e[i][k]+e[k][j])e[i][j]=e[i][k]+e[k][j];需要注意的是，为了保证更新成功，需要将e数组初始化为⽆穷⼤。
同时为了防⽌程序做⽆意义的到⾃⼰的最短路，将每个节点到本⾝的距离初始化为0。
算法复杂度：该算法的空间复杂度为n^2(不算优秀，但勉强接受),时间复杂度O(n^3)（呵呵）。
完整代码：#include<iostream>#include<cstring>#include<cstdio>using namespace std;const int inf=99999999;int n,m,x,y,z,s;int dis[1001][1001];int main(){scanf("%d%d%d",&n,&m,&s);for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)if(i!=j) dis[i][j]=inf;else dis[i][j]=0;for(int i=1;i<=m;i++){scanf("%d%d%d",&x,&y,&z);dis[x][y]=dis[y][x]=z;}for(int k=1;k<=n;k++)for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)if(dis[i][k]+dis[k][j]<dis[i][j])dis[i][j]=dis[i][k]+dis[k][j];for(int i=1;i<=n;i++)printf("%d ",dis[s][i]);return0;}算法优化：for(int k = 1; k <= n; k++)for(int i = 1; i <= n; i++)for(int j = 1; j <= i; j++)dis[i][j] = min(dis[i][j], dis[i][k]+dis[k][j]),dis[j][i] = dis[i][j];这⾥利⽤了矩阵的对称性，只更新⼀半矩阵即可。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Voidfind(int P[MAX_VERTEX_NUM][MAX_VERTEX_NUM][MAX_VERTEX_NUM],MGraph G,int a,int b){
int k;
for(k = 0; k < G.vexnum; k++)
if(P[a][b][k]==TRUE && k!=a && k!=b){
printf("%c到%c最短路径为",65+a,65+b);
printf("%c\t",65+a);
find(P,G,a,b);
printf("%c\t",65+b);
printf("长度为%d",D[a][b]);
printf("\n");
}
}
void find(int P[MAX_VERTEX_NUM][MAX_VERTEX_NUM][MAX_VERTEX_NUM],MGraphG,int a,int b){
// D[v][w]从v到w的最短路径的长度
for (v = 0; v < G.vexnum; v++)
for (w = 0; w < G.vexnum; w++){
D[v][w] = G.arcs[v][w];
for (k = 0; k < G.vexnum; k++)
P[v][w][k] = FALSE;
intvexnum,arcnum;//图的当前顶点数和弧数
GraphKindkind;//图的种类标志
}MGraph;
void find(int P[MAX_VERTEX_NUM][MAX_VERTEX_NUM][MAX_VERTEX_NUM],MGraph G,int a,int b);
void main(){
int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
int vexnum,arcnum;
GraphKind kind;
}MGraph;
源程序
#include<stdlib.h>
#include<stdio.h>
#define INFINITY 1000 //最大值
#define MAX_VERTEX_NUM 20 //最大顶点个数
D[v][w] = D[v][k] + D[k][w];
for (i = 0; i < G.vexnum; i++)
P[v][w][i] = P[v][k][i] || P[k][w][i];
}
for(a=0; a<G.vexnum; a++)
for(b=0; b<G.vexnum; b++)
if(D[a][b] < INFINITY && a!=b){
问题描述
实现Floyd算法，并求所示有向图中各顶点之间的最短路径及其长度。
算法思想
采用图的邻接矩阵存储，实现Floyd算法~，数组P[][][]存储是否存在中间点使长度缩短。
设计描述
数据存储结构类型的定义：
typedef struct MGraph{
char vexs[MAX_VERTEX_NUM];
find(P,G,a,k);
printf("\t%c",65+k);
f寻找是否存在中间点然后打印出来。
问题出在红色部分，判定是否采用递归，未考虑k是否与a b相同，结果导致无限递归。从而发现stack overflow的错误提示有可能出于递归无法跳出，导致栈的溢出问题。
MGraph G;
intD[MAX_VERTEX_NUM][MAX_VERTEX_NUM],P[MAX_VERTEX_NUM][MAX_VERTEX_NUM][MAX_VERTEX_NUM];
int v,w,k,a,b,i;
printf("请输入顶点数和弧数");
scanf("%d %d",&G.vexnum,&G.arcnum);
G.kind=DG;
printf("请输入邻接矩阵\n");
for (v = 0; v < G.vexnum; v++)
for (w = 0; w < G.vexnum; w++)
scanf("%d",&G.arcs[v][w]); //读入邻接矩阵
// P[v][w][k]为TRUE，则从v到w的最短路径中含有k节点
if (D[v][w] < INFINITY)
P[v][w][v] = P[v][w][w] = TRUE;
}
for (k = 0; k < G.vexnum; k++)
for (v = 0; v < G.vexnum; v++)
for (w = 0; w < G.vexnum; w++)
if (D[v][k] + D[k][w] < D[v][w]){
#define TRUE 1
#define FALSE 0
typedef enum{DG, DN, UDG, UDN}
GraphKind; //四种图类型
typedef struct MGraph{
charvexs[MAX_VERTEX_NUM];//顶点向量
intarcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];//邻接矩阵
int k;
for(k = 0; k < G.vexnum; k++)
if(P[a][b][k]==TRUE && k!=a && k!=b){
find(P,G,a,k);
printf("%c\t",65+k);
find(P,G,k,b);
}
}
测试结果
输入
（1000为无穷！~
输出
心得体会~。！！
懂得了floyd算法的思想，用邻接矩阵存储带权值的图。