Floyd算法---极有可能你和我的疑问一样！

Floyd算法—极有可能你和我的疑问一样！

极有可能你和我的疑问一样！

先看一个例子，看是否我们的问题一样！我画了一下午才捣鼓出来！

//理解图 自己画一画更容易理解

请输入图的结点and边数:6 9
请输入顶点信息:
请输入结点之间的关系:
a b 1
a c 12
b c 9
b d 3
d c 4
c e 5
e f 4
d f 15
d e 13

path！
-1      -1      3       1       3       4
-1      -1      3       -1      3       4
-1      -1      -1      -1      -1      4
-1      -1      -1      -1      2       4
-1      -1      -1      -1      -1      -1
-1      -1      -1      -1      -1      -1

我对path{0,5} 位置的数字3有疑问！我当时以为会是结点 C 就是下标2，结果出乎意料

我就去添加print()看从哪里开始“出错”，结果是在插入结点D时候出现“错误”

其实这不是错误，是Floyd算法的一部分，所以输出不能直接按照path的下标顺序来输出，而是借助递归函数···

一直找到起始点开始输出·····

参照视频： [我疑难问题的解决视频][最短路径Floyd算法_哔哩哔哩_bilibili]

[文章][(42条消息) Floyd算法详解——包括解题步骤与编程_SweeNeil的博客-CSDN博客_floyd算法步骤]

void printPath(int path[][maxsize],char u,char v,Graph G) { 现 真好哈哈哈
	if(path[seek(G,u)][seek(G,v)]==-1) {
		return ;
	} else {                           
		int mid=path[seek(G,u)][seek(G,v)];
		printPath(path,u,G.data[mid],G);  //u->v的顺序输出 
		printf("%c,",G.data[mid]);
		printPath(path,G.data[mid],v,G);
	}

源代码：

//求最短路径步骤：
//a.初始化一个n阶方阵，对角线为0，不存在边为无穷大 存在权值
//b.逐步试着在原直接路径中增加中间顶点，若加入中间顶点后路变短，则修改；否则，维持原值。所有顶带你试探完毕，算法结束。
#include<stdio.h>

#include<stdlib.h>

#define maxsize 100
#define INFINITE 999
typedef struct {
	char data[maxsize];//顶点信息
	int uv[maxsize][maxsize];//邻接矩阵
	int vexnum,arcnum;
} Graph; //图

int D[maxsize][maxsize];//记录<u,v>方向的最短路径的距离
int path[maxsize][maxsize];//记录此节点前最小路径的结点

void creatGraph(Graph &G);
int seek(Graph G,char u);
void printPath(int path[][maxsize],char u,char v,Graph G);
void creatGraph(Graph &G) {
	printf("创建图···\n");
	printf("请输入图的结点and边数:");
	scanf("%d %d",&G.vexnum,&G.arcnum);
	printf("请输入顶点信息:\n");
	getchar();
//	for(int i=0; i<G.vexnum; i++) {
//		scanf("%c%*c",&G.data[i]);
//	}//为方便测试，注释掉输入顶点信息
	G.data[0]='a';
	G.data[1]='b';
	G.data[2]='c';
	G.data[3]='d';
	G.data[4]='e';
	G.data[5]='f';
	//初始化uv邻接矩阵
	for(int i=0; i<G.vexnum; i++) {
		for(int j=0; j<G.vexnum; j++) {
			if(i==j)
				G.uv[i][j]=0;
			G.uv[i][j]=INFINITE;
		}
	}
	//正题
	printf("请输入结点之间的关系:\n");
	for(int i=0; i<G.arcnum; i++) {
		char u,v;
		int info;
		scanf("%c %c %d",&u,&v,&info);
		getchar();
		int ii=seek(G,u);
		int jj=seek(G,v);

		if(ii==-1||jj==-1) {
			printf("输入的结点信息有误\n");
			exit(0);
		}
		G.uv[ii][jj]=info;
	}
	printf("创建完成！\n");
}
int seek(Graph G,char u) {
	for(int i=0; i<G.vexnum; i++) {
		if(G.data[i]==u) return i;
	}
	return -1;
}

void Floyd(Graph G,int path[][maxsize],int D[][maxsize]) {

	for(int i=0; i<G.vexnum; i++) {
		for(int j=0; j<G.vexnum; j++) {
			path[i][j]=-1;
			D[i][j]=G.uv[i][j];
		}
	}
	//Floyd相对核心代码
	for(int k=0; k<G.vexnum; k++) {
		for(int u=0; u<G.vexnum; u++) {
			for(int v=0; v<G.vexnum; v++) {
				if(D[u][v]>(D[u][k]+D[k][v])) {
					D[u][v]=D[u][k]+D[k][v];
					path[u][v]=k;
				}
			}
		}
	}

}

//Floyd最核心代码
void printPath(int path[][maxsize],char u,char v,Graph G) { //重点！！！！
	if(path[seek(G,u)][seek(G,v)]==-1) {
		return ;
	} else {                          
		int mid=path[seek(G,u)][seek(G,v)];
		printPath(path,u,G.data[mid],G);  //u->v的顺序输出 
		printf("%c,",G.data[mid]);
		printPath(path,G.data[mid],v,G);
	}
}

int main() {
	Graph G;
	creatGraph(G);
	Floyd(G,path,D);

	printf("D！\n");
	for(int u=0; u<G.vexnum; u++) {
		for(int v=0; v<G.vexnum; v++) {
			printf("%d\t",D[u][v]);
		}
		printf("\n");
	}
	printf("path!\n");
	for(int u=0; u<G.vexnum; u++) {
		for(int v=0; v<G.vexnum; v++) {
			printf("%d\t",path[u][v]);

			printf("\n");
		}
		printf("各顶点之间的最短路径：\n");
		for(int i=0; i<G.vexnum; i++) {
			for(int j=0; j<G.vexnum; j++) {
				if(i==j) continue;

				if(D[i][j]==INFINITE) {
					//printf("%c~%c没有路径！\n",G.data[i],G.data[j]);
					continue;
				}

				printf("%c~%c最短路径：",G.data[i],G.data[j]);
				printf("%c,",G.data[i]);
				printPath(path,G.data[i],G.data[j],G);
				printf("%c,",G.data[j]);
				printf("\n");
			}
		}
	}
  return 0;
}

测试

创建图···
请输入图的结点and边数:6 9
请输入顶点信息:
请输入结点之间的关系:
a b 1
a c 12
b c 9
b d 3
d c 4
c e 5
e f 4
d f 15
d e 13
创建完成！
D！
999     1       8       4       13      17
999     999     7       3       12      16
999     999     999     999     5       9
999     999     4       999     9       13
999     999     999     999     999     4
999     999     999     999     999     999
path!
-1      -1      3       1       3       4
-1      -1      3       -1      3       4
-1      -1      -1      -1      -1      4
-1      -1      -1      -1      2       4
-1      -1      -1      -1      -1      -1
-1      -1      -1      -1      -1      -1
各顶点之间的最短路径：
a~b最短路径：a,b,
a~c最短路径：a,b,d,c,
a~d最短路径：a,b,d,
a~e最短路径：a,b,d,c,e,
a~f最短路径：a,b,d,c,e,f,
b~c最短路径：b,d,c,
b~d最短路径：b,d,
b~e最短路径：b,d,c,e,
b~f最短路径：b,d,c,e,f,
c~e最短路径：c,e,
c~f最短路径：c,e,f,
d~c最短路径：d,c,
d~e最短路径：d,c,e,
d~f最短路径：d,c,e,f,
e~f最短路径：e,f,

加油bro，文采不好，仅供参考！