Floyd算法

Floyd算法

Floyd算法：用来解决全源最短路问题，对给定的图G(V,E)，求任意两点u，v之间的最短路径长度。
邻接矩阵实现Floyd算法非常合适。
Floyd算法：如果存在顶点k，使得以k作为中介点时顶点 i 和顶点 j 的当前最短距离缩短，则使用顶点k作为顶点 i 和顶点 j 的中介点，即当dis[i][k]+dis[k][j]<dis[i][j]时，令dis[i][j] = dis[i][k]+dis[k][j](其中dis[i][j]表示从顶点 i 到顶点 j 的最短距离)。

从V₁到V₄的距离为3，而以V₂为中介点时可以使V₁到V₄的距离缩短为2，那么就把V₁到V₄的距离从3优化为2，即当dis[1][2]+dis[2][4]<dis[1][4]时，令dis[1][4]=dis[1][2]+dis[2][4]。

Floyd算法流程

枚举顶点k∈[1, n]
    以顶点k作为中介点，枚举所有顶点对i和j(i∈[1, n], j∈[1, n])
        如果dis[i][k] + dis[k][j] < dis[i][j]成立
            赋值dis[i][j] = dis[i][k] + dis[k][j]

以Dijkstra算法的例子

#include <cstdio>
#include <algorithm>
using namespace std;

const int INF = 1000000000;
const int MAXV = 200; //MAXV为最大顶点数
int n, m; //n为顶点数，m为边数
int dis[MAXV][MAXV]; //dis[i][j]表示顶点i和顶点j的最短距离

void Floyd()
{
	for(int k = 0; k < n; k++)
	{
		for(int i = 0; i < n; i++)
		{
			for(int j = 0; j < n; j++)
			{
				if(dis[i][k] != INF && dis[k][j] != INF && dis[i][k] + dis[k][j] < dis[i][j])
				{
					dis[i][j] = dis[i][k] + dis[k][j]; //找到更短的路径
				}
			}
		}
	}
}

int main()
{
	int u, v, w;
	fill(dis[0], dis[0] + MAXV * MAXV, INF); //dis数组赋初值
	scanf("%d%d", &n, &m); //顶点数n、边数m
	for(int i = 0; i < n; i++)
	{
		dis[i][i] = 0; //顶点i到顶点i的距离初始化为0
	}
	for(int i = 0; i < m; i++)
	{
		scanf("%d%d%d", &u, &v, &w);
		dis[u][v] = w; //以有向图为例进行输入
	}
	Floyd(); //Floyd算法入口
	for(int i = 0; i < n; i++) //输入dis数组
	{
		for(int j = 0; j < n; j++)
		{
			printf("%d", dis[i][j]);
		}
		printf("\n");
	}
	return 0;
}

//输入
6 8
0 1 1
0 3 4
0 4 4
1 3 2
2 5 1
3 2 2
3 4 3
4 5 3

//输出
0 1 5 3 4 6
1000000000 0 4 2 5 5
1000000000 1000000000 0 1000000000 1000000000 1
1000000000 1000000000 2 0 3 3
1000000000 1000000000 1000000000 1000000000 0 3
1000000000 1000000000 1000000000 1000000000 1000000000 0

注意：不能将最外层的k循环放到内层(产生i->j->k的三重循环)，如果当较后访问的dis[u][v]有了优化之后，前面访问的dis[i][j]会因为已经被访问而无法获得进一步优化(这里i、j先于u、v进行访问)