弗洛伊德算法求解最短路径
matlab的floyd算法
matlab的floyd算法Floyd算法，是一种图论算法，用于在加权图中求解最短路径。
它是以发明者之一、罗伯特·弗洛伊德的名字命名的。
这个算法同样被用于对于任意两点之间的最长路径（所谓的最短路径问题）进行求解。
算法描述给定一个带权的有向图G=(V,E)，其权值函数为w，下面我们定义从顶点i到顶点j的路径经过的最大权值为dist(i,j)。
特别地，当i=j时，dist(i,j)=0。
为了方便描述算法，我们用D(k,i,j)表示从顶点i到顶点j且路径中的所有顶点都在集合{1,2,⋯,k}中的所有路径中，最大边权值的最小值。
则从顶点i到顶点j的最短路径的边权值就是 D(n,i,j)，其中n是图中顶点的数量。
算法思想：建立中间顶点集合算法是通过不断地扩充中间顶点集合S，来求解任意两点之间的最短路径。
具体来说，设S={1, 2, ⋯, k}，其中k是整数。
Floyd算法的基本思想是，依次考察所有可能的中间顶点x（即所有S中的顶点），对于每个中间顶点x，若从i到x再到j的路径比已知的路径更短，则更新dist(i,j)为更小的值D(k,i,j)。
最终，在S={1, 2, ⋯, n}的情况下，所得到的D(n,i,j)就是顶点i到顶点j之间的最短路径的长度。
Floyd算法的核心是一个三重循环，在每一轮循环中，枚举S中所有的中间顶点x，通过动态规划计算出从i到j的最短路径长度D(k,i,j)。
这一过程可表述为：for k = 1 to nfor i = 1 to nfor j = 1 to nif D(k,i)+D(j,k) < D(k,i,j)D(k,i,j) = D(k,i)+D(j,k)其中D(0,i,j)即为dist(i,j)，若i和j不连通，则D(0,i,j)=+Inf。
算法实现function D = Floyd(adjmat)% adjmat为邻接矩阵邻接矩阵adjmat的定义为：- 若两个顶点之间有边相连，则对应位置为该边的边权值；- 若两个顶点之间没有边相连，则对应位置为0。
floyd算法步骤详解
floyd算法步骤详解Floyd算法步骤详解Floyd算法，又称为弗洛伊德算法，是一种解决任意两点间最短路径的算法。
该算法的核心思想是动态规划，通过遍历每一个中间节点来更新每条路径上的最短距离。
下面，我们来详细了解一下Floyd算法的步骤。
步骤1：构造邻接矩阵我们需要构造出一个邻接矩阵，用来表示地图上的各个节点之间的连接情况。
邻接矩阵一般用二维数组来表示，其中数组的下标表示节点编号，数组的值表示两个节点之间的距离或权值。
如果两个节点之间没有连接，则可以用一个很大的数表示它们之间的距离。
步骤2：初始化距离矩阵接下来，我们需要初始化一个距离矩阵，用来存储任意两点之间的最短距离。
距离矩阵同样也是一个二维数组，其中数组的下标表示起点和终点的节点编号，数组的值表示两个节点之间的最短距离。
初始化的时候，如果两个节点之间有连接，则距离矩阵中的对应位置存储的值为它们之间的距离，否则设置为一个很大的数。
步骤3：遍历中间节点接下来，我们需要遍历每一个中间节点，更新距离矩阵中的值。
具体的遍历方式是，从起点到终点遍历所有的中间节点，如果中间节点可以使起点和终点之间的距离更短，则更新距离矩阵中的值。
步骤4：更新距离矩阵在遍历中间节点的过程中，我们需要不断地更新距离矩阵中的值。
具体的更新方式是，如果起点到中间节点的距离加上中间节点到终点的距离小于起点到终点的距离，则更新距离矩阵中对应的值。
步骤5：输出最短路径在完成所有的遍历之后，距离矩阵中存储的就是任意两点之间的最短距离。
我们可以根据这个矩阵来输出任意两点之间的最短路径。
具体的输出方式是，从起点开始，依次找到距离它最近的节点，直到到达终点为止。
总结Floyd算法是一种经典的解决任意两点间最短路径的算法，虽然它的时间复杂度比较高，但是它的思想和实现方式都非常简单，容易理解。
如果你想深入学习算法和数据结构，那么Floyd算法是一个非常好的入门选择。
弗洛伊德算法在生活中的应用
弗洛伊德算法在生活中的应用
弗洛伊德算法是一种求解最短路径问题的算法，它的应用非常广泛，
包括以下几个方面：
1.地图寻路：在地图应用中，弗洛伊德算法可以用来寻找两个地点之
间的最短路径，例如在导航软件中，可以通过弗洛伊德算法快速计算出最
短路径并提供导航指引。
2.通信网络：在通信网络中，弗洛伊德算法可以用来计算网络中节点
之间的最短路径，例如在路由器中使用弗洛伊德算法可以确定数据包的最
短路径，从而提高通信速率。
3.交通规划：在城市交通规划中，弗洛伊德算法可以用来计算不同交
通路线的最短路径，从而优化交通流量和减少拥堵。
4.电子游戏：在电子游戏中，弗洛伊德算法可以用来计算角色移动的
最短路径，从而使游戏角色更智能化。
总之，弗洛伊德算法在生活中有许多应用场景，可以帮助人们更快速、更高效地解决问题。
第11周图(下)第4讲-求最短路径的Floyd算法
path3
3
0
1
2
3
7
0
-1
0
31
0
2
1
2 -1 31
1
2
2
2
2
-1
2
0
3
2
2
3
-1
求最终结果
A3
0
1
2
3
0
0
5
8
7
1
6
0
3
2
2
3
3
0
2
3
4
4
1
0
path3
0
1
2
30-10301
2
-1
3
1
2
2
2
-1
2
3
2
2
3
-1
求最短路径长度：
由A3数组可以直接得到两个顶点之间的最短路径长度。 如A3[1][0]=6 说明顶点1到0的最短路径长度为6。
pathx[i][j]表示考虑过0～x的顶点得到i j的最短路径，该路径上顶点j的 前一个顶点。
已经考虑过0～k-1顶 点的情况
k
a
i
……
b
j
现在考虑顶点k
pathk-1[i][j]=b
若经过顶点k的路径更短： pathk[i][j] = a = pathk-1[k][j] 否则： pathk[i][j] = b = pathk-1[i][j] 不改变
Floyd算法示例演示
0
7 34
51
3
2
2
2
3
1
A-1
0
1
2
弗洛伊德算法求解最短路径
弗洛伊德算法求解最短路径算法的基本思想是采用动态规划的方式，逐步地计算图中所有顶点对之间的最短路径长度。
算法首先初始化一个二维数组D，其中D[i][j]表示从顶点i到顶点j的最短路径长度。
初始时，D[i][j]的值为无穷大，表示顶点i到顶点j没有直接路径。
然后，算法通过逐步更新D数组的值，不断地优化顶点对之间的最短路径。
算法的具体步骤如下：1.初始化D数组：对于图中的每一对顶点i和j，如果i等于j，则置D[i][j]=0，表示顶点到自身的距离为0；否则，如果i和j之间有边存在，则置D[i][j]为边的权重，否则置为无穷大。
2.对于图中的每一个顶点k，依次考虑顶点对(i,j)，其中i和j分别表示图中的任意两个顶点。
如果从顶点i先经过顶点k再到达顶点j的路径长度小于当前D[i][j]的值，则更新D[i][j]为新的较短路径长度。
3.对于每一对顶点i和j，以每一个顶点k为中间节点，重复步骤2、这样，在每一次迭代中，D数组会根据当前的顶点k得到更短的路径。
4.根据更新后的D数组，可以得到任意两个顶点之间的最短路径长度。
如果需要获取最短路径上的具体路径，则可以使用一个辅助数组P，其中P[i][j]表示从顶点i到顶点j的最短路径上，从顶点i到顶点j前一个顶点的编号。
通过回溯P数组，可以得到最短路径上的所有顶点。
弗洛伊德算法的时间复杂度为O(n^3)，其中n表示图中顶点的个数。
由于要对所有顶点对之间的路径长度进行计算，因此算法的运行时间较长。
然而，该算法适用于复杂图中的最短路径计算，可以得到任意两个顶点之间的最短路径及其长度。
弗洛伊德算法在实际应用中有广泛的应用。
例如，在路由算法中，可以使用弗洛伊德算法来计算网络中所有节点之间的最短路径，并根据计算结果进行路由选择。
此外，弗洛伊德算法也可以应用于交通规划、航空航线优化等领域。
总之，弗洛伊德算法是一种用于求解图中所有顶点对之间最短路径的动态规划算法。
通过逐步更新路径长度的方式，可以得到任意两个顶点之间的最短路径及其长度。
弗洛伊德（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算法求解最短路径问题(完整程序代码)
引言在图论中经常会遇到这样的问题，在一个有向图里求出任意两个节点之间的最短距离。
当节点之间的权值是正值的时候，我们可以采用Dijkstra算法，用贪心策略加于解决。
但当节点之间的权值有负数的时候，Dijkstra就行不通了，这里介绍另外一种算法—Floyd最短路径算法。
对于任意图，选择存储结构存储图并实现FLOYD算法求解最短路经。
将问题分解，分解为两方面。
一是对于任意图的存储问题，第二个是实现FLOYD算法求解最短路经。
首先对于图的创建选择合适的存储结构进行存储，对于合适的存储结构可以简化程序。
本实验采用邻接矩阵存储。
然后是实现FLOYD算法求解最短路经，在FLOYD算法中路径的长度即是图中两定点间边的权值，FLOYD算法要求输出任意两个顶点间的最短路径，而且经过的顶点也要输出。
考虑到问题的特殊性，采用一个二维数组和一个三维数组进行存储。
二维数组存储最短路径，三维数组存储路径经过的顶点，在进行适当的算法后对这两个数组进行输出即可。
通过问题的分解，逐个解决，事先所要求的程序。
最短路径算法问题是计算机科学、运筹学、地理信息系统和交通诱导、导航系统等领域研究的一个热点。
传统的最短路径算法主要有Floyd算法和Dijkstra算法。
Floyd算法用于计算所有结点之间的最短路径。
Dijkstra算法则用于计算一个结点到其他所有结点的最短路径。
Dijkstra算法是已经证明的能得出最短路径的最优解，但它的效率是一个很大的问题。
对于具有n个结点的一个图，计算一个结点到图中其余结点最短路径的算法时间复杂度为O(n2)。
对于一座大中型城市，地理结点数目可能达到几万个到几十万个，计算最短路径的时间开销将是非常巨大的。
本文根据吴一民老师的建议，分析当前存在的各种求最短路径的算法，提出一种新的基于层次图的最短路径算法，即将一个平面图划分若干子图，子图抽象为一个高层图。
最短路径的计算首先在高层图中进行，缩小了最短路径的查找范围，降低了最短路径计算的时间开销。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
课程设计任务书目录第1章概要设计 (1)1.1题目的内容与要求 (1)1.2总体结构 (1)第2章详细设计 (2)2.1主模块 (2)2.2构建城市无向图 (3)2.3添加城市 (4)2.4修改城市距离 (5)2.5求最短路径 (6)第3章调试分析 (7)3.1调试初期 (7)3.2调试中期 (7)3.3调试末期 (7)第4章测试及运行结果 (7)附页（程序清单） (10)第1章概要设计1.1题目的内容与要求内容：给出一张无向图，图上的每个顶点表示一个城市，顶点间的边表示城市间存在路径，边上的权值表示城市间的距离。
试编写程序求解从某一个城市出发到达任意其他任意城市的最短路径问题。
要求：1)能够提供简单友好的用户操作界面，可以输入城市的基本信息，包括城市名称，城市编号等；2)利用矩阵保存城市间的距离；3)利用Floyd算法求最短路径；4)独立完成系统的设计，编码和调试；5)系统利用C语言完成；6)按照课程设计规范书写课程设计报告。
1.2总体结构本程序主要分为四个模块（功能模块见图1.1）：主模块对整个程序起一主导作用，开始构建一城市无向图，对其进行添加城市顶点，以及对原来的距离数据进行修改，整体构建结束可以实现求一城市到其他城市的最短路径问题。
图1.1 功能模块图第2章详细设计2.1主模块用户根据屏幕上显示的操作提示输入要进行操作的模块，通过调用相对应的模块程序，达到用户所想进行操作。
程序的总框架大致分为四个模块：1.建立城市无向图2.添加城市模块3.修改城市距离4.求最短路径。
具体实现过程见2.2：建立城市无向图2.3：添加城市2.4：修改城市距离2.5：求最短路径。
流程图中通过输入n，由n的值来选择调用相对应子函数，实现所选择的功能，调用完后可以返回调用主函数进行下一次选择，从而实现反复调用子函数而实现四个模块的功能等。
图2.1 主模块流程图2.2构建城市无向图根据提示输入城市，对城市无向矩阵图进行初始化，开始g.v[m][n].path的路径值赋为-2表示p城到q城间中间没有可达的路径不经过其他城市，而g.v[m][n].distance赋值为0表示p到p的距离为0。
流程图中的MAX表示的是最多的城市数量，其值为20；p，q表示城市的编号，而path和distance分别表示的路径和城市间距离。
g.v[p][q].distace表示p、q代表的城市间的距离图2.2 构建城市无向图流程图2.3添加城市用户根据提示输入想要添加到无向图中的城市，根据屏幕中的提示输入与之邻接的城市间的距离，然后添加城市距离矩阵图中；同时将g.v[m][n].path赋值为-1即表示p城到q城有路可达且最短路径无需经过其他城市。
需注意的是当g.v[m][n].distance=0表示p城到q城的距离为0，当g.v[m][n].distance=99999，则表示p城到q城距离无穷大即表示他们之间无路径可达，而当g.v[m][n].distance=k(0<k<99999)时表示他们间的距离是k。
流程图中g.n表示当前图中存储的城市数量，dis表示输入的城市间的距离即q和g.n 表示城市间的距离。
通过q<g.n的条件判断来充分完成图对应的矩阵中的赋值。
图2.3 添加城市流程图2.4修改城市距离根据屏幕上的城市编号，输入想更改的城市编号。
在进行该模块时会输出原来的距离。
由于在现实生活中由于一些人为的测量误差或是一些自然因素，又或是城市整编等等一系列的因素需要改动原来的城市距离，此时应用该块修改的功能即可实现更改，且根据提示操作简单，用户具体可以参看第四章：测试及运行结果。
流程图中p,q 表示城市的编号，根据p 和q 可以找到对应的城市名称，找到对应的g.v[p][q].distance 即是原来两城市间的距离。
图2.4 修改城市距离流程图2.5求最短路径利用Floyd求最短路径，假设vi到 vj存在路径，长度为k，假设vi到vj 经过vk(i=0 1…..n)长度为m,比较k和m,如果k>m,则d(vi,vj)=m,否则为k，依次类推，直到所有的vi到vj的中间城市比较完，最后d(vi,vj)的值即为最短距离，同时在比较的过程中保存路径信息，最后在查询时即可输出路径。
具体见第四章：测试及运行结果中求最短路径界面图2.4 修改城市距离流程图第3章调试分析3.1 调试初期由于编写的程序具有模块化的特性，且VC 6.0 的调试显然由于TC及个人对VC的熟练程度远优于TC等方面，我选择先在VC 6.0环境下完成除图形化演示算法过程函数的其他过程。
由于数据结构选择的较合理，对Floyd算法的理解较为深刻，所以在此环境下的调试并没有太多困难。
3.2 调试中期在上机输入完程序后，出现了许多错误，其中有一些小错误，比如说忘记写分号，在这些错误上双击，找到位置，加上分号。
还有就是程序中的有的变量在前面没有定义，只要在前面添加上就可以了。
再有就是前后的类型要保持一致，在这块我也犯了个错误。
前面是指针类型，后面却是取地址类型，解决办法就是把前面的改成指针类型，保持前后一致。
还有就是遗忘分号，逗号，解决方法就是，一步一步的把遗忘的分号，逗号补上。
忘记定义变量的类型。
比i应该是整型的却忘记申明。
解决方法就是在函数内先申明int 类型的i.。
粗心导致很多细节问题，比如该输入英文的括号的，却输成中文的括号，解决方法，把中英文分开。
注意细节问题。
3.3 调试末期输入的数据无法找出正确的路径，解决方法，一步一步的调试，找出问题的所在，改正逻辑错误。
在同学的帮助下，找到了逻辑错误，一步一步地改正，终于得到预期的结果。
第4章测试及运行结果建图过程：根据屏幕上的显示输入，你会看到如下界面；添加城市过程：根据界面提示操作，结果如下，添加一城市后如下：我总共添加了三个城市，最后结果如下界面：求最短路径过程：根据提示我输入了0 2号城市编号，结果如下：同理根据提示输入要修改的城市编号，输入后，屏幕上会显示原来的距离，输入修改后的距离即可修改成功。
附页（程序清单）#include "stdafx.h"#include<stdio.h>#include<string.h>#include<stdlib.h>#include <malloc.h>#define MAX 20 //城市数量typedef struct{int path;int distance;} Vert;typedef struct{int n;//存放顶点数char name[MAX][60];//城市名称及编号Vert v[MAX][MAX];} Mgraph;void path(Mgraph g,int m,int n,int f){int k,i,a[21];for(i=0;i<21;i++)a[i]=-3;k=g.v[m][n].path;if(k>=0){f++;a[f]=k;k=g.v[m][k].path;path(g,m,k,f);k=g.v[k][n].path;path(g,k,n,f);}for(i=1;a[i]>=0;i++){printf("%s到%s途经:",[m],[n]);printf("%s ",[a[i]] );}}void Floyd(Mgraph g){int i,j,k,m,n,h=0,w=0,f=0,s;for(k=0;k<g.n-1;k++){for(i=0;i<g.n-1;i++)for(j=0;j<g.n;j++){if(g.v[i][j].distance>g.v[i][k].distance+g.v[k][j].distance){g.v[i][j].distance=g.v[i][k].distance+g.v[k][j].distance;g.v[j][i].distance=g.v[i][j].distance;g.v[i][j].path=k;g.v[j][i].path=g.v[i][j].path;}}}printf("输入你要查询的两城市编号\n");printf("以下是城市相对应的编号:\n");for(i=0;i<g.n;i++){w++;printf("%s: %d ",[i],i);if(w%g.n==0)printf("\n");}scanf("%d%d",&m,&n);printf("%s和%s的最短距离是%d\n",[m],[n],g.v[m][n].distance);s=g.v[m][n].path;if(s==-1)printf("%s到%s最短路径不途经其他城市\n",[m],[n]);if(s>=0)path(g,m,n,f);}Mgraph Modify(Mgraph g) // 修改俩城市的数据{int p,q,s;printf("输入要修改的两城市编号\n",g.v[p][q].distance);scanf("%d%d",&p,&q);printf("原来两城市距离为%d\n");printf("修改两城市间的距离\n");scanf("%d",&s);g.v[p][q].distance=s;return g;}Mgraph ADD(Mgraph g) // 添加新的城市{int p=0,q=0,dis;char s;printf("请输入添加城市的名字\n");scanf("%s",&[g.n]);for(q=0;q<g.n;q++){printf("%s和%s是否邻接是的：1 不是：0\n",[q],[g.n]);scanf("%d",&p);if(p==1)//邻接信息{g.v[q][g.n].path=-1;printf("请输入%s和%s间的距离\n",[q],[g.n]);scanf("%d",&dis);g.v[q][g.n].distance=dis;g.v[g.n][q].distance=dis;}else{g.v[q][g.n].distance=99999;//99999表示距离的无限大值g.v[g.n][q].distance=99999;//99999表示距离的无限大值}}g.n++;return g;}//添加结束Mgraph Init(Mgraph g)//初始化一个邻接矩阵无向图{int q=0,p=0;g.n=1;printf("请输入第一个城市的名称\n");scanf("%s",[0]);for(q=0;q<MAX;q++)for(p=0;p<MAX;p++){g.v[p][q].path=-2;g.v[q][q].distance=0 ;}return g;}//初始化结束void main(){int i,m=0;Mgraph p;do{printf("|__________________________________|\n");printf("| 选择操作 |\n"); printf("| 1. 创建一个图 |\n");printf("| 2. 添加一个新的城市 |\n");printf("| 3. 修改现有城市的数据 |\n");printf("| 4. 求最短路径 |\n");printf("| 5.退出程序 |\n");printf("|__________________________________|\n");scanf("%d",&i);switch(i){case 1:p=Init(p);break;//初始化case 2:p=ADD(p);break;//添加城市case 3:p=Modify(p);break;//修改城市数据case 4:Floyd(p);break;//弗洛伊的算法case 5:exit(0);break;//退出程序}printf("是否继续 1：继续 0：退出\n");scanf("%d",&m);system("cls");}while(m==1);}。