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算法步骤详解Floyd算法，又称为弗洛伊德算法，是一种解决任意两点间最短路径的算法。
该算法的核心思想是动态规划，通过遍历每一个中间节点来更新每条路径上的最短距离。
下面，我们来详细了解一下Floyd算法的步骤。
步骤1：构造邻接矩阵我们需要构造出一个邻接矩阵，用来表示地图上的各个节点之间的连接情况。
邻接矩阵一般用二维数组来表示，其中数组的下标表示节点编号，数组的值表示两个节点之间的距离或权值。
如果两个节点之间没有连接，则可以用一个很大的数表示它们之间的距离。
步骤2：初始化距离矩阵接下来，我们需要初始化一个距离矩阵，用来存储任意两点之间的最短距离。
距离矩阵同样也是一个二维数组，其中数组的下标表示起点和终点的节点编号，数组的值表示两个节点之间的最短距离。
初始化的时候，如果两个节点之间有连接，则距离矩阵中的对应位置存储的值为它们之间的距离，否则设置为一个很大的数。
步骤3：遍历中间节点接下来，我们需要遍历每一个中间节点，更新距离矩阵中的值。
具体的遍历方式是，从起点到终点遍历所有的中间节点，如果中间节点可以使起点和终点之间的距离更短，则更新距离矩阵中的值。
步骤4：更新距离矩阵在遍历中间节点的过程中，我们需要不断地更新距离矩阵中的值。
具体的更新方式是，如果起点到中间节点的距离加上中间节点到终点的距离小于起点到终点的距离，则更新距离矩阵中对应的值。
步骤5：输出最短路径在完成所有的遍历之后，距离矩阵中存储的就是任意两点之间的最短距离。
我们可以根据这个矩阵来输出任意两点之间的最短路径。
具体的输出方式是，从起点开始，依次找到距离它最近的节点，直到到达终点为止。
总结Floyd算法是一种经典的解决任意两点间最短路径的算法，虽然它的时间复杂度比较高，但是它的思想和实现方式都非常简单，容易理解。
如果你想深入学习算法和数据结构，那么Floyd算法是一个非常好的入门选择。
Floyd算法思想及操作详解
二、Warshall和Floyd算法
2. Floyd算法 • Floyd算法用于计算距离矩阵，即每个顶点到其他 所有顶点之间的距离(最短路径的长度)
二、Warshall和Floyd算法
2. Floyd算法 • 算法思想 – 算法考虑每对顶点最短路径上的中间顶点 – dij (k)等于从第i个顶点到第j个顶点之间所有路径 中一条最短路径的长度，并且路径的每一个中 间顶点（如果有的话）的编号不大于k – 有递推关系式
DW for k 1 to n do for i 1 to n do for j 1 to n do D[i, j] min{D[i, j], D[i, k]+D[k, j]} return D
算法分析： 时间效率分析：Θ(n³ )
二、Warshall和Floyd算法
1. Floyd算法 • 例题 – p223，习题8.2，第7题：对下面具有权重矩阵 的有向图，求解完全最短路径 0 2 1 8 6 0 3 2 0 4 2 0 3 3 0 • 思考 – p223，习题8.2，第10题
二、Warshall和Floyd算法
Floyd算法
a 2 7 b 3
•
例
c
1
6
d
二、Warshall和Floyd算法
二、Warshall和Floyd算法
2. Floyd算法 • 算法
Floyd(W[1..n,1..n]) // 实现计算完全最短路径的Floyd算法 // 输入：图的权重矩阵W // 输出：包含最短路径长度的距离矩阵
( ( ( ( dijk ) min{dijk 1) , dikk 1) d kjk 1) }, (0) dij wij
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算法
简介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算法又称为弗洛伊德算法，插点法，是一种用于寻找给定的加权图中顶点间最短路径的算法。
改算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。
目录核心思路算法过程时间复杂度优缺点分析改进和优化算法实现pascal语言java算法展开核心思路算法过程时间复杂度优缺点分析改进和优化算法实现pascal语言java算法展开编辑本段核心思路通过一个图的权值矩阵求出它的每两点间的最短路径矩阵。
从图的带权邻接矩阵A=[a(i,j)] n×n开始，递归地进行n次更新，即由矩阵D(0)=A，按一个公式，构造出矩阵D(1)；又用同样地公式由D(1)构造出D(2)；……；最后又用同样的公式由D(n-1)构造出矩阵D(n)。
矩阵D(n)的i行j列元素便是i号顶点到j号顶点的最短路径长度，称D(n)为图的距离矩阵，同时还可引入一个后继节点矩阵path来记录两点间的最短路径。
采用的是(松弛技术)，对在i和j之间的所有其他点进行一次松弛。
所以时间复杂度为O(n^3);其状态转移方程如下：map[i,j]:=min{map[i,k]+map[k,j],map[i,j]}map[i,j]表示i到j的最短距离K是穷举i,j的断点map[n,n]初值应该为0，或者按照题目意思来做。
当然，如果这条路没有通的话，还必须特殊处理，比如没有map[i,k]这条路编辑本段算法过程1，从任意一条单边路径开始。
所有两点之间的距离是边的权，如果两点之间没有边相连，则权为无穷大。
2，对于每一对顶点u 和v，看看是否存在一个顶点w 使得从u 到w 再到v 比己知的路径更短。
如果是更新它。
编辑本段时间复杂度O(n^3)编辑本段优缺点分析Floyd算法适用于APSP(All Pairs Shortest Paths)，是一种动态规划算法，稠密图效果最佳，边权可正可负。
java算法 floyd算法
java算法 floyd算法Floyd算法是一种用于解决图中所有节点之间最短路径问题的算法。
该算法以其简洁高效的特点而被广泛应用于网络路由算法、城市交通规划等领域。
本文将详细介绍Floyd算法的原理和实现过程。
一、算法原理Floyd算法采用动态规划的思想，通过不断更新节点之间的最短路径来求解问题。
它的核心思想是，假设图中的节点集合为V，任意两个节点i和j之间的最短路径为d(i,j)，则对于任意节点k，如果节点k在节点i和节点j之间作为中转节点，则节点i和节点j之间的最短路径可以通过节点k来实现，即d(i,j) = min{d(i,k) + d(k,j)}。
基于这个思想，Floyd算法通过不断更新所有节点之间的最短路径，最终得到所有节点之间的最短路径。
二、算法实现下面我们详细介绍Floyd算法的实现过程。
1. 初始化我们需要定义一个二维数组dist，用于存储任意两个节点之间的最短路径长度。
如果节点i和节点j之间有边相连，则dist[i][j]的值为边的权重；如果节点i和节点j之间没有边相连，则dist[i][j]的值为无穷大。
同时，我们还需要定义一个二维数组path，用于存储节点i和节点j之间的最短路径经过的节点。
2. 更新最短路径接下来，我们使用三层循环来更新所有节点之间的最短路径。
外层循环遍历所有节点k，中层循环遍历所有节点i，内层循环遍历所有节点j。
在每次循环中，我们判断节点i和节点j之间的最短路径是否可以通过节点k来实现，如果可以，则更新最短路径和路径经过的节点。
3. 输出最短路径我们可以通过遍历dist数组来输出任意两个节点之间的最短路径长度。
同时，我们还可以通过遍历path数组来输出任意两个节点之间的最短路径经过的节点。
三、算法分析Floyd算法的时间复杂度为O(n^3)，其中n为图中节点的个数。
该算法的空间复杂度为O(n^2)，因为需要使用一个二维数组来存储任意两个节点之间的最短路径长度。
v 弗洛伊德算法
v 弗洛伊德算法弗洛伊德算法（Floyd’s algorithm），又称为插点法，是一种通过动态规划求解最短路径问题的算法。
该算法在图论中有着广泛的应用，能够快速求解出两点之间的最短路径。
本文将为大家介绍弗洛伊德算法的原理以及实际应用。
1. 算法原理弗洛伊德算法的核心思想是利用中间点来更新起点到终点的距离。
假设图中任意两点之间的距离都为$d[i][j]$，则我们假设存在一个中间点$k$，可以将起点$i$和终点$j$之间的最短路径分成两部分，即起点到中间点的路径$d[i][k]$和中间点到终点的路径$d[k][j]$。
所以我们可以得到如下的状态转移方程：$$d[i][j]=\min(d[i][j],d[i][k]+d[k][j])$$通过不断地更新所有点之间的最短路径，我们最终可以得到所有节点之间的最短路径。
2. 算法实现弗洛伊德算法的实现中，最重要的一步就是更新状态转移方程。
具体来说，我们需要使用三层循环嵌套遍历所有点，将当前节点到所有其他节点的最短距离更新一遍即可。
下面就是使用 Python 语言实现弗洛伊德算法的代码片段：```pythonn = len(graph)for k in range(n):for i in range(n):for j in range(n):graph[i][j] = min(graph[i][j], graph[i][k] +graph[k][j])```在这段代码中，$graph$是一个$n \times n$的矩阵，表示所有节点之间的距离。
其中$n$是节点的数量。
3. 算法应用弗洛伊德算法的主要应用是求解带权图中各个节点之间的最短路径。
在实际生活中，我们可以将节点看作是城市，将距离看作是两个城市之间的道路距离。
这样，就可以使用弗洛伊德算法来计算任意两座城市之间的最短路程，帮助人们规划出更加便捷的旅行路线。
另外，在计算机网络中，弗洛伊德算法也被广泛应用于路由协议的设计中。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
求最短路径算法总结分类：数据结构标签：floyd算法it部分内容参考All-Pairs 的最短路径问题:所有点对之间的最短路径Dijkstra算法是求单源最短路径的，那如果求图中所有点对的最短路径的话则有以下两种解法：解法一：以图中的每个顶点作为源点，调用Dijkstra算法，时间复杂度为O(n3)；解法二：Floyd（弗洛伊德算法）更简洁，算法复杂度仍为O(n3)。
n正如大多数教材中所讲到的，求单源点无负边最短路径用Dijkstra，而求所有点最短路径用Floyd。
确实，我们将用到Floyd算法，但是，并不是说所有情况下Floyd都是最佳选择。
对于没有学过Floyd的人来说，在掌握了Dijkstra之后遇到All-Pairs最短路径问题的第一反应可能会是：计算所有点的单源点最短路径，不就可以得到所有点的最短路径了吗。
简单得描述一下算法就是执行n次Dijkstra算法。
Floyd可以说是Warshall算法的扩展了，三个for循环便可以解决一个复杂的问题，应该说是十分经典的。
从它的三层循环可以看出，它的复杂度是n3，除了在第二层for中加点判断可以略微提高效率，几乎没有其他办法再减少它的复杂度。
比较两种算法，不难得出以下的结论：对于稀疏的图，采用n次Dijkstra比较出色，对于茂密的图，可以使用Floyd算法。
另外，Floyd可以处理带负边的图。
下面对Floyd算法进行介绍：Floyd算法的基本思想：可以将问题分解，先找出最短的距离，然后在考虑如何找出对应的行进路线。
如何找出最短路径呢，这里还是用到动态规划的知识，对于任何一个城市而言，i到j的最短距离不外乎存在经过i与j之间的k和不经过k两种可能，所以可以令k=1，2，3，...，n(n是城市的数目)，在检查d(ij)与d(ik)+d(kj)的值；在此d(ik)与d(kj)分别是目前为止所知道的i到k 与k到j的最短距离，因此d(ik)+d(kj)就是i到j经过k的最短距离。
所以，若有d(ij)>d(ik)+d(kj)，就表示从i出发经过k再到j的距离要比原来的i到j距离短，自然把i到j的d(ij)重写为d(ik)+d(kj)，每当一个k查完了，d(ij)就是目前的i到j的最短距离。
重复这一过程，最后当查完所有的k时，d(ij)里面存放的就是i到j之间的最短距离了。
Floyd算法的基本步骤：定义n×n的方阵序列D-1, D0 , … Dn－1,初始化：D-1＝CD-1[i][j]＝边<i,j>的长度，表示初始的从i到j的最短路径长度，即它是从i到j的中间不经过其他中间点的最短路径。
迭代：设Dk-1已求出，如何得到Dk（0≤k≤n-1）？Dk-1[i][j]表示从i到j的中间点不大于k-1的最短路径p：i…j，考虑将顶点k加入路径p得到顶点序列q：i…k…j，若q不是路径，则当前的最短路径仍是上一步结果：Dk[i][j]= Dk－1[i][j]；否则若q的长度小于p的长度，则用q取代p作为从i到j的最短路径。
因为q的两条子路径i…k和k…j皆是中间点不大于k－1的最短路径，所以从i到j中间点不大于k的最短路径长度为：Dk[i][j]＝min{ Dk-1[i][j], Dk-1[i][k] +Dk-1[k][j] }Floyd算法实现：可以用三个for循环把问题搞定了，但是有一个问题需要注意，那就是for循环的嵌套的顺序：我们可能随手就会写出这样的程序，但是仔细考虑的话，会发现是有问题的。
for(int i=0; i<n; i++)for(int j=0; j<n; j++)for(int k=0; k<n; k++)问题出在我们太早的把i-k-j的距离确定下来了，假设一旦找到了i-p-j最短的距离后，i 到j就相当处理完了，以后不会在改变了，一旦以后有使i到j的更短的距离时也不能再去更新了，所以结果一定是不对的。
所以应当象下面一样来写程序：for(int k=0; k<n; k++)for(int i=0; i<n; i++)for(int j=0; j<n; j++)这样作的意义在于固定了k，把所有i到j而经过k的距离找出来，然后象开头所提到的那样进行比较和重写，因为k是在最外层的，所以会把所有的i到j都处理完后，才会移动到下一个k，这样就不会有问题了，看来多层循环的时候，我们一定要当心，否则很容易就弄错了。
接下来就要看一看如何找出最短路径所行经的城市了，这里要用到另一个矩阵P，它的定义是这样的：p(ij)的值如果为p，就表示i到j的最短行经为i->...->p->j，也就是说p是i 到j的最短行径中的j之前的最后一个城市。
P矩阵的初值为p(ij)=i。
有了这个矩阵之后，要找最短路径就轻而易举了。
对于i到j而言找出p(ij)，令为p，就知道了路径i->...->p->j；再去找p(ip)，如果值为q，i到p的最短路径为i->...->q->p；再去找p(iq)，如果值为r，i到q的最短路径为i->...->r->q；所以一再反复，到了某个p(it)的值为i时，就表示i到t的最短路径为i->t，就会的到答案了，i到j的最短行径为i->t->...->q->p->j。
因为上述的算法是从终点到起点的顺序找出来的，所以输出的时候要把它倒过来。
但是，如何动态的回填P矩阵的值呢？回想一下，当d(ij)>d(ik)+d(kj)时，就要让i到j 的最短路径改为走i->...->k->...->j这一条路，但是d(kj)的值是已知的，换句话说，就是k->...->j 这条路是已知的，所以k->...->j这条路上j的上一个城市(即p(kj))也是已知的，当然，因为要改走i->...->k->...->j这一条路，j的上一个城市正好是p(kj)。
所以一旦发现d(ij)>d(ik)+d(kj)，就把p(kj)存入p(ij)。
下面是具体的C代码：#include <stdio.h>#include <limits.h>#include <stdlib.h>#define MAXSIZE 20void floyd(int [][MAXSIZE], int [][MAXSIZE], int);void display_path(int [][MAXSIZE], int [][MAXSIZE], int);void reverse(int [], int);void readin(int [][MAXSIZE], int *);#define MAXSUM(a, b) (((a) != INT_MAX && (b) != INT_MAX) ? \((a) + (b)) : INT_MAX)void floyd(int dist[][MAXSIZE], int path[][MAXSIZE], int n){int i, j, k;for (i = 0; i < n; i++)for (j = 0; j < n; j++)path[i][j] = i;for (k = 0; k < n; k++)for (i = 0; i < n; i++)for (j = 0; j < n; j++)if (dist[i][j] > MAXSUM(dist[i][k], dist[k][j])){path[i][j] = path[k][j];dist[i][j] = MAXSUM(dist[i][k], dist[k][j]);}}void display_path(int dist[][MAXSIZE], int path[][MAXSIZE], int n) {int *chain;int count;int i, j, k;printf("\n\nOrigin->Dest Dist Path");printf( "\n-----------------------------");chain = (int *) malloc(sizeof(int)*n);for (i = 0; i < n; i++)for (j = 0; j < n; j++){if (i != j){printf("\n%6d->%d ", i+1, j+1);if (dist[i][j] == INT_MAX)printf(" NA ");else{printf("%4d ", dist[i][j]);count = 0;k = j;do{k = chain[count++] = path[i][k];} while (i != k);reverse(chain, count);printf("%d", chain[0]+1);for (k = 1; k < count; k++)printf("->%d", chain[k]+1);printf("->%d", j+1);}}}free(chain);}#define SWAP(a, b) { temp = a; a = b; b = temp; } void reverse(int x[], int n){int i, j, temp;for (i = 0, j = n-1; i < j; i++, j--)SW AP(x[i], x[j]);}void readin(int dist[][MAXSIZE], int *number){int origin, dest, length, n;int i, j;char line[100];gets(line);sscanf(line, "%d", &n);*number = n;for (i = 0; i < n; i++){for (j = 0; j < n; j++)dist[i][j] = INT_MAX;dist[i][i] = 0;}gets(line);sscanf(line, "%d%d%d", &origin, &dest, &length);while (origin != 0 && dest != 0 && length != 0){dist[origin-1][dest-1] = length;gets(line);sscanf(line, "%d%d%d", &origin, &dest, &length);}}/// 测试程序如下所示：int main(void){int dist[MAXSIZE][MAXSIZE];int path[MAXSIZE][MAXSIZE];int n;printf("\nInput the path information:");printf("\n----------------------------\n");readin(dist, &n);floyd(dist, path, n);display_path(dist, path, n);getchar();}其中readin函数规定了输入的格式，第一列是指出有多少个城市；第二列以后每行三个数；第一个和第二个是一条路径的起点和终点，第三个数是路径的长度，最后以三个0作为输入结束条件。