图论最短路径-Floyd算法-CSDN博客

本文链接：https://blog.csdn.net/spcier/article/details/148493215

最短路径：对应不带权图则表示起始点到目标点的所用的最少边数的路径；对应带权图则表示起始点到目标点的权值之和最小的路径。

Floyd算法核心思想：动态规划思想，利用中间点k来求它的最短路径，它的状态转移方程为：dp[i][j]=min{dp[i][j],dp[i][k]+dp[k][j]}; dp[i][j]为目前已知的i->j的最短路径。

例如，更新0->2的最短路径，已知0->2目前最短路径为6

我们遍历到1为中间点的时候，发现0->1->2的路径值为5<6,则我们更新0->2的最短路径为5，且1->2的前驱结点为0。

所以，给出应该带权有向图

首先定义各点到各点的最短路径的二维数组arr，和路径二维数组path

int arr[7][7];          //用于存放各个点到其他的点的最短长度
int path[7][7];         //用于存放最短路径

接着初始化这两个数组，arr数组初始化为连通图的值，也就是各点到其他点的直接权值，

如果各点到其他的点有边这设置 i->j 的前驱结点为 i ，否则为-1

for (int i = 0;i < 7;i++) {
	for (int j = 0;j < 7;j++) {
		arr[i][j] = g[i][j];    //初始最短距离为邻接矩阵的直接权值（未经过中间节点）
		if (g[i][j] != 0 && g[i][j] < INF) {     //存放路径
			path[i][j] = i;                      //若i-j有边，则存放前驱点i
		}
		else {
			path[i][j] = -1;                     //i-j无边，置为-1，表示暂时没有前驱；
		}
	}
}

从顶点0到6开始，逐个作为中间点

由于点0入度为0（即没有边指向点0），所以其他点到剩余点的路径不变

接着到点1作为中间点，遍历从点 i（除中间点 1 外）到剩余点 j ，将点 i 到点 j 与点 i -> 1 -> j 的值进行比较，如果i->j的值< i -> 1 -> j 的值，则更新 i -> j 的最小路径为 i -> 1 -> j 的值，并且设置1-> j 的前驱点为 i。直至遍历完 j 点，再开始更新 i 点; 直到 i 点遍历完，接着更新中间点k

for (int k = 0;k < 7;k++) {                   //顶点0~6开始作为一个中间点
	for (int i = 0;i < 7;i++) {
		for (int j = 0;j < 7;j++) {
			if (arr[i][j] > arr[i][k] + arr[k][j]) {     //比较i->j的值和i->k->j的值，如果大于经过中间点k则更新值
				arr[i][j] = arr[i][k] + arr[k][j];
				path[i][j] = path[k][j];                 //更新路径，j的前驱为k->j的前驱
			}
		}
	}
}

以此类推……

代码如下：

#include<iostream>
using namespace std;
const int INF = 1e9;
int g[7][7] = {           //连通图邻接矩阵
	{0  ,4  ,6  ,6  ,INF,INF,INF},
	{INF,0  ,1  ,INF,7  ,INF,INF},
	{INF,INF,0  ,INF,6  ,4  ,INF},
	{INF,INF,2  ,0  ,INF,5  ,INF},
	{INF,INF,INF,INF,0  ,INF,6  },
	{INF,INF,INF,INF,1  ,0  ,8  },
	{INF,INF,INF,INF,INF,INF,0  }
};
int arr[7][7];          //用于存放各个点到其他的点的最短长度
int path[7][7];         //用于存放最短路径
void floyd() {
	for (int i = 0;i < 7;i++) {
		for (int j = 0;j < 7;j++) {
			arr[i][j] = g[i][j];    //初始最短距离为邻接矩阵的直接权值（未经过中间节点）
			if (g[i][j] != 0 && g[i][j] < INF) {     //存放路径
				path[i][j] = i;                      //若i-j有边，则存放前驱点i
			}
			else {
				path[i][j] = -1;                     //i-j无边，置为-1，表示暂时没有前驱；
			}
		}
	}
	for (int k = 0;k < 7;k++) {                   //顶点0~6开始作为一个中间点
		for (int i = 0;i < 7;i++) {
			for (int j = 0;j < 7;j++) {
				if (arr[i][j] > arr[i][k] + arr[k][j]) {     //比较i->j的值和i->k->j的值，如果大于经过中间点k则更新值
					arr[i][j] = arr[i][k] + arr[k][j];
					path[i][j] = path[k][j];                 //更新路径，j的前驱为k->j的前驱
				}
			}
		}
	}
}
void dispath() {    // 用于输出各到各点的最小路径值以及路径
	for (int i = 0;i < 7;i++) {
		for (int j = 0;j < 7;j++) {
			if (arr[i][j] < INF && i != j) {           //输出已求出最短路径的顶点（不包含本身）
				printf(" %d 到 %d 的径为：", i, j);
				int k = path[i][j];      //将k赋为i->j的前驱结点
				int d = 0;
				int path1[7];        //用于逆序输出路径
				path1[d] = j;        //添加终点 j
				while (k!= i) {     //不断将路径放入path1中
					path1[++d] = k;
					k = path[i][k];     //更新k为i-k的上一个点
				}
				path1[++d] = i;      //最后将起始点放入path1中
				printf("%d ", path1[d]);  //反向输出路径
				for (int s = d - 1;s >= 0;s--) {
					printf(",%d ", path1[s]);
				}
				printf("\t路径长度为:%d\n", arr[i][j]);

			}
		}
		printf("\n");
	}
}
int main() {
	floyd();
	dispath();
	return 0;
}

结果如下：