下载文档原格式
两点之间最短路径算法（实用版）目录1.算法简介2.常用算法3.算法应用4.算法优缺点正文【算法简介】两点之间最短路径算法是一种计算图（例如地图、社交网络等）中两个节点之间最短路径的算法。
在实际应用中，找到最短路径可以帮助我们节省时间、金钱和资源。
这类算法有很多种，如 Dijkstra 算法、Floyd-Warshall 算法和 Bellman-Ford 算法等。
【常用算法】1.Dijkstra 算法：该算法使用贪心策略，每次选择距离起点最近的节点进行扩展，直到到达终点。
它适用于有向图和无向图，但不适用于存在负权边的图。
2.Floyd-Warshall 算法：该算法使用动态规划策略，通过计算每个节点到其他所有节点的距离，来寻找最短路径。
它适用于有向图和无向图，也可以处理负权边，但不适用于存在负权环的图。
3.Bellman-Ford 算法：该算法结合了 Dijkstra 算法和Floyd-Warshall 算法的优点，可以在存在负权边的图中寻找最短路径，同时可以检测出是否存在负权环。
【算法应用】两点之间最短路径算法在现实生活中有很多应用，例如：1.地图导航：通过计算用户所在位置与目的地之间的最短路径，帮助用户规划出行路线。
2.社交网络：计算用户与其好友之间的最短路径，以便更快速地传递信息或找到共同的兴趣点。
3.物流配送：计算货物从产地到销售地的最短路径，以降低运输成本和提高效率。
【算法优缺点】优点：1.可以处理大规模的图结构。
2.可以找到最短路径，有助于节省时间和资源。
缺点：1.对于大规模的图，计算复杂度较高，可能导致计算速度较慢。
2.对于存在负权环的图，Bellman-Ford 算法也无法找到最短路径。
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。
c语言最短路径搜寻算法
C 语言最短路径搜寻算法常用于在网图中寻找两点之间的最短路径，其中网图的最短路径分为单源最短路径和多源最短路径。
以下是两种常见的最短路径搜寻算法：- Dijkstra 算法：从一个起始点出发，到达一个终点，通过对路径权值的累加，找到最短路径。
- Floyd 算法：对于网中的任意两个顶点来说，之间的最短路径不外乎有两种情况。
一种是直接从一个顶点到另一个顶点的边的权值；另一种是先经过若干个顶点，最终达到另一个顶点，期间经过的边的权值和。
这两种算法都可以用 C 语言实现，你可以根据具体需求选择合适的算法。
若你想了解更多关于最短路径搜寻算法的内容，可以继续向我提问。
基于Floyd算法的最优路径规划问题基于Floyd算法的最优路径规划问题一、引言路径规划在现代社会中起着重要作用，涉及到交通、物流、电信等诸多领域。
而在路径规划中，如何寻找最优路径一直是研究的热点问题之一。
Floyd算法，作为一种常用的最短路径算法，被广泛应用于最优路径规划问题。
本文将介绍Floyd算法的基本原理以及在最优路径规划问题中的应用。
二、Floyd算法的基本原理Floyd算法是一种动态规划算法，用于计算图中任意两点之间的最短路径。
它通过构建一个二维矩阵来记录顶点之间的最短路径长度，并逐步更新矩阵中的距离值，直到得到最终的最短路径。
Floyd算法的基本原理可以归纳为以下几个步骤：1. 初始化距离矩阵，设置所有点之间的距离为无穷大。
同时将直接相连的点的距离设置为它们之间的权值。
2. 通过遍历所有点，逐步更新距离矩阵中的值。
对于当前点i和j之间的路径，如果经过一个中转点k可以使得路径变短，就更新距离矩阵中的对应距离值为较短的路径长度。
3. 重复第2步，直到遍历完所有点。
最后得到的距离矩阵中的值就是每一对顶点之间的最短路径长度。
三、最优路径规划问题分析最优路径规划问题可以用图的形式表示，其中顶点表示地点，边表示路径，边的权值表示路径的长度或者花费。
在实际应用中，最优路径规划问题可以有不同的约束条件，例如最短路径、最少花费路径、最优时间路径等。
基于Floyd算法的最优路径规划问题实质上就是在已知图的基础上，通过计算任意两点之间的最短路径长度来确定最优路径。
借助Floyd算法，我们可以使用距离矩阵来表示点之间的距离，通过更新矩阵来找到最短路径。
四、基于Floyd算法的最优路径规划问题应用实例为了更好地理解基于Floyd算法的最优路径规划问题的应用，我们以一个城市交通网络为例进行分析。
假设一个城市有n个交叉口，这些交叉口之间通过道路相连。
我们的目标是从一个起点到达一个终点，寻找一条最短路径。
此时，我们可以将城市交通网络抽象为一个图，其中交叉口表示顶点，道路表示边，边的权值表示路径的长度。
引言在图论中经常会遇到这样的问题，在一个有向图里求出任意两个节点之间的最短距离。
当节点之间的权值是正值的时候，我们可以采用Dijkstra算法，用贪心策略加于解决。
但当节点之间的权值有负数的时候，Dijkstra就行不通了，这里介绍另外一种算法—Floyd最短路径算法。
对于任意图，选择存储结构存储图并实现FLOYD算法求解最短路经。
将问题分解，分解为两方面。
一是对于任意图的存储问题，第二个是实现FLOYD算法求解最短路经。
首先对于图的创建选择合适的存储结构进行存储，对于合适的存储结构可以简化程序。
本实验采用邻接矩阵存储。
然后是实现FLOYD算法求解最短路经，在FLOYD算法中路径的长度即是图中两定点间边的权值，FLOYD算法要求输出任意两个顶点间的最短路径，而且经过的顶点也要输出。
考虑到问题的特殊性，采用一个二维数组和一个三维数组进行存储。
二维数组存储最短路径，三维数组存储路径经过的顶点，在进行适当的算法后对这两个数组进行输出即可。
通过问题的分解，逐个解决，事先所要求的程序。
最短路径算法问题是计算机科学、运筹学、地理信息系统和交通诱导、导航系统等领域研究的一个热点。
传统的最短路径算法主要有Floyd算法和Dijkstra算法。
Floyd算法用于计算所有结点之间的最短路径。
Dijkstra算法则用于计算一个结点到其他所有结点的最短路径。
Dijkstra算法是已经证明的能得出最短路径的最优解，但它的效率是一个很大的问题。
对于具有n个结点的一个图，计算一个结点到图中其余结点最短路径的算法时间复杂度为O(n2)。
对于一座大中型城市，地理结点数目可能达到几万个到几十万个，计算最短路径的时间开销将是非常巨大的。
本文根据吴一民老师的建议，分析当前存在的各种求最短路径的算法，提出一种新的基于层次图的最短路径算法，即将一个平面图划分若干子图，子图抽象为一个高层图。
最短路径的计算首先在高层图中进行，缩小了最短路径的查找范围，降低了最短路径计算的时间开销。
matlab floyd算法
Floyd算法是一种用于求解最短路径的算法，它可以在有向图或者无向图中找到任意两个顶点之间的最短路径。
Floyd算法的核心思想是动态规划，它通过不断更新每个顶点之间的距离来求解最短路径。
Floyd算法的基本思路是，对于图中的任意两个顶点i和j，如果存在一条从i到j的路径，那么这条路径的长度就是i到j的最短路径。
如果不存在这样的路径，那么i到j的最短路径就是无穷大。
Floyd 算法通过不断更新每个顶点之间的距离来求解最短路径。
Floyd算法的实现过程比较简单，它可以用一个二维数组来表示图中每个顶点之间的距离。
初始时，这个数组的值就是图中每个边的权值。
然后，对于每个顶点k，我们都尝试更新从i到j的最短路径。
如果从i到k再到j的路径比当前的最短路径更短，那么我们就更新这个最短路径。
Floyd算法的时间复杂度为O(n^3)，其中n是图中顶点的个数。
虽然这个时间复杂度比较高，但是Floyd算法的实现比较简单，而且它可以处理带有负权边的图。
因此，在实际应用中，Floyd算法还是比较常用的。
Floyd算法是一种用于求解最短路径的算法，它通过不断更新每个顶点之间的距离来求解最短路径。
虽然它的时间复杂度比较高，但
是它的实现比较简单，而且它可以处理带有负权边的图。
因此，在实际应用中，Floyd算法还是比较常用的。
实验四：Floyd 算法一、实验目的利用MATLAB实现Floyd算法，可对输入的邻接距离矩阵计算图中任意两点间的最短距离矩阵和路由矩阵，且能查询任意两点间的最短距离和路由。
二、实验原理Floyd算法适用于求解网络中的任意两点间的最短路径：通过图的权值矩阵求出任意两点间的最短距离矩阵和路由矩阵。
优点是容易理解，可以算出任意两个节点之间最短距离的算法，且程序容易实现，缺点是复杂度达到，不适合计算大量数据。
Floyd算法可描述如下：给定图G及其边(i , j )的权w i, j (1 <i<n ,1 <j <n)F0:初始化距离矩阵W(0)和路由矩阵R(0)。
其中：[ 叫若弓巴E (有边)叫⑴二｛丈若牛匸F(无边)'0 若i = j(对角线元素)严J j若吋S°\ 0,其它F1：已求得W(k-1)和R(k-1)，依据下面的迭代求W(k)和R(k)F2 :若k<n，重复F1;若k>n，终止。
三、实验内容1、用MATLAB仿真工具实现Floyd算法：给定图G及其边(i , j )的权w i , j (1 <i <n ,1 <j <n)，求出其各个端点之间的最小距离以及路由(1) 尽可能用M 函数分别实现算法的关键部分，用 M 脚本来进行算法结果验证;(2) 分别用以下两个初始距离矩阵表示的图进行算法验证:分别求出 W (7)和R (7) 2、根据最短路由矩阵查询任意两点间的最短距离和路由(1)最短距离可以从最短距离矩阵的3 (i,j)中直接得出；(2)相应的路由则可以通过在路由矩阵中查找得出。
由于该程序中使用的是前向矩 阵，因此在查找的过程中，路由矩阵中 r(i,j)对应的值为Vi 到Vj 路由上的下一个端 点，这样再代入r(r(i,j),j)，可得到下下个端点，由此不断循环下去， 即可找到最终 的路由。
(3)对图1，分别以端点对V4和V6, V3和V4为例，求其最短距离和路由；对图2，分别以端点对V1和V7，V3和V5，V1和V6为例，求其最短距离和路由。
Floyd算法Floyd算法又称为弗洛伊德算法，插点法，是一种用于寻找给定的加权图中顶点间最短路径的算法。
核心思路：通过一个图的权值矩阵求出它的每两点间的最短路径矩阵。
从图的带权邻接矩阵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 来记录两点间的最短路径。
算法过程：把图用邻接距阵G表示出来，如果从Vi到Vj有路可达，则G[i,j]=d，d表示该路的长度；否则G[i,j]=无穷大。
定义一个距阵D用来记录所插入点的信息，D[i,j]表示从Vi到Vj需要经过的点，初始化D[i,j]=j。
把各个顶点插入图中，比较插点后的距离与原来的距离，G[i,j] = min( G[i,j], G[i,k]+G[k,j] )，如果G[i,j]的值变小，则D[i,j]=k。
在G中包含有两点之间最短道路的信息，而在D中则包含了最短通路径的信息。
比如，要寻找从V5到V1的路径。
根据D，假如D(5,1)=3则说明从V5到V1经过V3，路径为{V5,V3,V1}，如果D(5,3)=3，说明V5与V3直接相连，如果D(3,1)=1，说明V3与V1直接相连。
优缺点分析：Floyd算法适用于APSP(All Pairs Shortest Paths)，稠密图效果最佳，边权可正可负。
此算法简单有效，由于三重循环结构紧凑，对于稠密图，效率要高于执行|V|次Dijkstra算法。
优点：容易理解，可以算出任意两个节点之间的最短距离，代码编写简单；缺点：时间复杂度比较高，不适合计算大量数据。
Floyd算法的基本思想：（1）利用二维数组A[1..n-1][1..n-1], A[i][j]记录当前vi到vj的最短路径长度，数组A的初值等于图的代权临街矩阵;（2）集合S记录当前允许的中间顶点，初值S=Φ;（3）依次向S中加入v0 ,v1… vn-1，每加入一个顶点，对A[i][j]进行一次修正：设S={v0 ,v1… vk-1}，加入vk，则A(k)[i][j] = min{ A(k-1)[i][j]，A(k-1)[i][k]+A(k-1)[k][j]}。
数据结构floyd算法求最短路径一、简介Floyd算法是一种用于求解图中任意两点之间最短路径的算法，也称为插点法。
它采用动态规划的思想，通过不断地添加中间节点来逐步求解最短路径。
Floyd算法的时间复杂度为O(n^3)，适用于较小规模的图。
二、基本思想Floyd算法通过一个二维数组来存储任意两点之间的最短距离，初始化时，该数组存储的是图中各个节点之间的直接距离。
然后，对于每一个中间节点k，遍历整个二维数组，并更新任意两个节点i和j之间的距离，使得i到j经过k时距离更小。
最终得到的二维数组就是任意两点之间的最短距离。
三、具体实现1. 初始化二维数组D，D[i][j]表示节点i到节点j的直接距离。
2. 三重循环遍历整个二维数组D，在每次循环中将节点k作为中转节点，更新D[i][j]。
3. 更新公式：D[i][j] = min(D[i][j], D[i][k]+D[k][j])。
4. 循环结束后得到的二维数组就是任意两点之间的最短距离。
四、代码实现```void floyd(int n, int D[][MAX]){for(int k=1; k<=n; k++){for(int i=1; i<=n; i++){for(int j=1; j<=n; j++){D[i][j] = min(D[i][j], D[i][k]+D[k][j]);}}}}```五、应用场景Floyd算法适用于较小规模的图，一般用于解决稠密图（边数接近节点数平方）中任意两点之间的最短路径问题。
它可以用于计算城市间的最短路程、网络中的最短路径等。
六、优缺点分析优点：1. 算法思想简单，易于理解和实现。
2. 可以求解任意两点之间的最短路径。
3. 时间复杂度为O(n^3)，适用于较小规模的图。
缺点：1. 空间复杂度较高，需要开辟二维数组存储各个节点之间的距离。
2. 对于大规模稀疏图，算法效率较低。
3. 无法处理存在负权回路的图。
Floyd（弗洛伊德）算法（C语⾔）转载：Floyd算法的介绍算法的特点弗洛伊德算法是解决任意两点间的最短路径的⼀种算法，可以正确处理有向图或有向图或负权（但不可存在负权回路)的最短路径问题，同时也被⽤于计算有向图的传递闭包。
算法的思路通过Floyd计算图G=(V,E)中各个顶点的最短路径时，需要引⼊两个矩阵，矩阵S中的元素a[i][j]表⽰顶点i(第i个顶点)到顶点j(第j个顶点)的距离。
矩阵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]。
更新N次之后，操作完成！补充：以下⾯图为例⼦，b[i][j]中存储的是Vi~Vj之间的中介点，b[i][j]初始值为j，⽐如V0~V3最短路径是V0-->V2-->V1-->v3，在计算最短路径时转换为V0-->V2的距离加上V2-->V3的最短距离，接下来类似于递归，V2-->V3的最短路径就是以V1为中介点，V2-->V1的距离加上V1-->V3的距离。
因此，b[0][3]=2实例说明将整体分为两个步骤1.计算metrixD矩阵(两顶点之间的最短距离)和P矩阵(两顶点的中介点)#include <stdio.h>#include <stdlib.h>void Create_metrixD_P(int** metrixD, int **P ,int VerNum, int EdgNum){int x, y, Weight, edg_count = 0;int i, j, k;for (i = 0; i < VerNum; ++i) {for (j = 0; j < VerNum; ++j) {metrixD[i][j] = INT_MAX;P[i][j] = j;}}while (edg_count < EdgNum) {scanf("%d%d%d", &x, &y, &Weight);metrixD[x - 1][y - 1] = Weight;edg_count++;}}//Floyd algorithmvoid Floyd(int **metirxD, int **P, int VerNum) {int n, x, y, temp = 0;//The triple loop looks for shortest paths and weightsfor (n = 0; n < VerNum; ++n) {for (x = 0; x < VerNum; ++x) {for (y = 0; y < VerNum; ++y) {//The distance between two vertices is compared to the distance through a vertextemp = (metirxD[x][n] == INT_MAX || metirxD[n][y] == INT_MAX) ? INT_MAX : (metirxD[x][n] + metirxD[n][y]);if (temp < metirxD[x][y]) {//Update matrix informationmetirxD[x][y] = temp;P[x][y] = n;}}}}}void Show_metrixD_P(int** metrixD, int **P, int VerNum){int x, y;printf("metrixD:\n");for (x = 0; x < VerNum; ++x) {for (y = 0; y < VerNum; ++y) {if (metrixD[x][y] == INT_MAX) {printf("∞ ");}else {printf("%d ", metrixD[x][y]);}}printf("\n");}printf("P:\n");for (x = 0; x < VerNum; ++x) {for (y = 0; y < VerNum; ++y) {printf("%d ", P[x][y]);}printf("\n");}}int main(void){int VerNum, EdgNum, i;int** metrixD, ** P;printf("Enter the number of vertices and edges:");scanf("%d%d", &VerNum, &EdgNum);metrixD = (int**)malloc(VerNum * sizeof(int));P = (int**)malloc(VerNum * sizeof(int));for (i = 0; i < VerNum; ++i) {metrixD[i] = (int*)malloc(VerNum * sizeof(int));P[i] = (int*)malloc(VerNum * sizeof(int));}printf("Input vertices and weights:");Create_metrixD_P(metrixD, P, VerNum, EdgNum);Floyd(metrixD, P, VerNum);Show_metrixD_P(metrixD, P, VerNum);for (i = 0; i < VerNum; ++i) {free(metrixD[i]);free(P[i]);}free(metrixD);free(P);return0;}2.输出顶点之间的最短距离与路径#include <stdio.h>#include <stdlib.h>#define VEXNUM 5//Adjacency matrix: shows the distance between verticesint metirxD[VEXNUM][VEXNUM] = {INT_MAX,10, 5, INT_MAX,INT_MAX,INT_MAX,INT_MAX,2, 1, INT_MAX,INT_MAX,3, INT_MAX,9, 2,INT_MAX,INT_MAX,INT_MAX,INT_MAX,4,7, INT_MAX,INT_MAX,5, INT_MAX};//Path: passing vertex between two verticesint P[VEXNUM][VEXNUM] = {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};//Floyd algorithmvoid Floyd() {int n, x, y, temp = 0;//The triple loop looks for shortest paths and weightsfor (n = 0; n < VEXNUM; ++n) {for (x = 0; x < VEXNUM; ++x) {for (y = 0; y < VEXNUM; ++y) {//The distance between two vertices is compared to the distance through a vertextemp = (metirxD[x][n] == INT_MAX || metirxD[n][y] == INT_MAX) ? INT_MAX : (metirxD[x][n] + metirxD[n][y]);if (temp < metirxD[x][y]) {//Update matrix informationmetirxD[x][y] = temp;P[x][y] = n;}}}}}void Show_Path() {int x, y, temp = 0;//Output the shortest path between two verticesfor (x = 0; x < VEXNUM - 1; ++x) {for (y = x + 1; y < VEXNUM; ++y) {printf("V%d-->V%d weight:%d path:V%d", x, y, metirxD[x][y], x);temp = P[x][y];while (temp != y) {printf("-->V%d", temp);temp = P[temp][y];}printf("-->V%d", y);printf("\n");}}}int main(void){Floyd();Show_Path();return0;}完整代码#include <stdio.h>#include <stdlib.h>void Create_metrixD_P(int** metrixD, int **P ,int VerNum, int EdgNum){int x, y, Weight, edg_count = 0;int i, j, k;for (i = 0; i < VerNum; ++i) {for (j = 0; j < VerNum; ++j) {metrixD[i][j] = INT_MAX;P[i][j] = j;}}while (edg_count < EdgNum) {scanf("%d%d%d", &x, &y, &Weight);metrixD[x - 1][y - 1] = Weight;edg_count++;}}//Floyd algorithmvoid Floyd(int **metirxD, int **P, int VerNum) {int n, x, y, temp = 0;//The triple loop looks for shortest paths and weightsfor (n = 0; n < VerNum; ++n) {for (x = 0; x < VerNum; ++x) {for (y = 0; y < VerNum; ++y) {//The distance between two vertices is compared to the distance through a vertextemp = (metirxD[x][n] == INT_MAX || metirxD[n][y] == INT_MAX) ? INT_MAX : (metirxD[x][n] + metirxD[n][y]);if (temp < metirxD[x][y]) {//Update matrix informationmetirxD[x][y] = temp;P[x][y] = n;}}}}}void Show_metrixD_P(int** metrixD, int **P, int VerNum){int x, y;printf("metrixD:\n");for (x = 0; x < VerNum; ++x) {for (y = 0; y < VerNum; ++y) {if (metrixD[x][y] == INT_MAX) {printf("∞ ");}else {printf("%d ", metrixD[x][y]);}}printf("\n");}printf("P:\n");for (x = 0; x < VerNum; ++x) {for (y = 0; y < VerNum; ++y) {printf("%d ", P[x][y]);}printf("\n");}}void Show_Path(int **metirxD, int **P, int VerNum) {int x, y, temp = 0;//Output the shortest path between two verticesfor (x = 0; x < VerNum - 1; ++x) {for (y = x + 1; y < VerNum; ++y) {printf("V%d-->V%d weight:%d path:V%d", x, y, metirxD[x][y], x); temp = P[x][y];while (temp != y) {printf("-->V%d", temp);temp = P[temp][y];}printf("-->V%d", y);printf("\n");}}}int main(void){int VerNum, EdgNum, i;int** metrixD, ** P;printf("Enter the number of vertices and edges:");scanf("%d%d", &VerNum, &EdgNum);metrixD = (int**)malloc(VerNum * sizeof(int));P = (int**)malloc(VerNum * sizeof(int));for (i = 0; i < VerNum; ++i) {metrixD[i] = (int*)malloc(VerNum * sizeof(int));P[i] = (int*)malloc(VerNum * sizeof(int));}printf("Input vertices and weights:");Create_metrixD_P(metrixD, P, VerNum, EdgNum);Floyd(metrixD, P, VerNum);Show_metrixD_P(metrixD, P, VerNum);Show_Path(metrixD, P, VerNum);for (i = 0; i < VerNum; ++i) {free(metrixD[i]);free(P[i]);}free(metrixD);free(P);return0;}。
