图论最短路径之Floyed算法

在一些带权图里面，时长需要我们求出某一点到另一点的最短距离，floyed算法就是求最短路径的算法之一。其核心思想是经过某点中转，加入A点到B点的距离是10，B点到C点的距离为5，A点到C点的距离为20（此图将距离设定为权值），而且该图为有向图。图的形状如下图所示：

可以看出，如果直接从A点到C点，权值是20，如果经过B点中转，然后到达C点，那么权值将变为15，这就是A到C点的最短路径（A->B->C）。众所周知，我们可以使用二维数组来存储图（该二维数组被称为邻接矩阵），当我们需要求最短路径时，在中转时，判断A点到C点的距离是否大于A点到B点再到C点的距离，如果大于将更新邻接矩阵中的A到C点的距离为A点到B点再到C点的距离

if(length[A][C]>length[A][B]+length[B][C])
   length[A][C]=length[A][B]+length[B][C]

 如果给了N个点，那么将需要N次中转。因为邻接矩阵是一个NxN的二维数组，我们需要遍历这个数组。如下一个例子，首先给出点的个数和点的坐标，在给出点的连接关系，求出S点到T点的距离（S和T为用户的输入数据）

1.点的个数和坐标

4

1 1（第一个点）

2 3（第二个点）

3 4 （第三个点）

4 5（第四个点）

2.点的连接关系

1 2（表示第一个点和第二个点是联通的）

2 3

3 4

1 4

3.用户输入

S=2,T=4;

源码：

floyed.cpp

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
void floyed(double arr[][10],int m) {//floyed算法
	for (int k = 0; k < m; k++) {
		for (int i = 0; i < m; i++) {
			for (int j = 0; j < m; j++) {
				if ((i != j )&& (i != k) && (j != k) && (arr[i][k] + arr[k][j] < arr[i][j])) {
					arr[i][j] = arr[i][k] + arr[k][j];//更新邻接矩阵的值
				}
			}
		}
	}
}

main.cpp

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cmath>
#include <vector>
#include <cstring>
using namespace std;
void floyed(double arr[][10],int m) {//floyed算法
	for (int k = 0; k < m; k++) {
		for (int i = 0; i < m; i++) {
			for (int j = 0; j < m; j++) {
				if ((i != j )&& (i != k) && (j != k) && (arr[i][k] + arr[k][j] < arr[i][j])) {
					arr[i][j] = arr[i][k] + arr[k][j];
				}
			}
		}
	}
}
int main(){
	vector<vector<double> > array;
	int m;
	cin >> m;//点的个数
	for (int i = 0; i < m; i++) {
		vector<double> nums;
		int x, y;
		cin >> x >> y;//横纵坐标
		nums.push_back(x);
		nums.push_back(y);
		array.push_back(nums);
	}
	int n;
	cin >> n;
	double arr[10][10];//邻接矩阵存图
	for (int i = 0; i <= 9; i++) {
		for (int j = 0; j <= 9; j++) {
			if (i == j) {
				arr[i][j] == 0;
			}
			else {
			    arr[i][j] = 1000000007;//初始化邻接矩阵，是最大值说明两点不可达
			}
		}
	}
	for (int i = 0; i < n; i++) {
		int x, y;//两个点是否联通
		cin >> x >> y;
		x = x - 1; //减一是因为邻接矩阵的下标从0开始
		y = y - 1;
		arr[x][y] = sqrt(pow(double(array[x][0]-array[y][0]),2)+pow(double(array[x][1]-array[y][1]),2));//求出联通两点之间的距离
		arr[y][x] = arr[x][y];
	}
	floyed(arr, m);//调用floyed算法
	int s, t;
	cin >> s >> t;
	s = s - 1;
	t = t - 1;
	cout << arr[s][t] << endl;
	return 0;
}

运行结果：

第二个点到第四个点的最短距离为2.82843。该算法时间复杂度为O(N^3)，虽然该算法可以处理带有负权值的图，但是不能处理负环的图。负环，又叫负权回路，负权环，指的是一个图中存在一个环，里面包含的边的边权总和<0。在存在负环的图中，是求不出最短路径的，因为只要在这个环上不停的兜圈子，最短路径就会无限小。