最短路径——Floyd

Floyd-Warshall算法的时间复杂度为O(N^3)，空间复杂度为O(N^2)。

适用于多元最短路, 效率较低, 建图只能用邻接矩阵，可以有负边，但不能有负环，可以检测负环（方法：dis[i][i]<0，则存在负环）。

Floyd算法是基于动态规划的，依次扫描每个点，并以此点为中介，计算出经过该点的路径（i, j）的最短路径。

弗洛伊德（Floyd）算法过程：
１、用D[v][w]记录每一对顶点的最短距离。
２、依次扫描每一个点，并以其为基点再遍历所有每一对顶点D[][]的值，看看是否可用过该基点让这对顶点间的距离更小。

对于这个算法,网上有一个证明的版本：

 floyd算法是一个经典的动态规划算法。用通俗的语言来描述的话，首先我们的目标是寻找从点i到点j的最短路径。从动态规划的角度看问题，我们需要为这个目标重新做一个诠释（这个诠释正是动态规划最富创造力的精华所在），floyd算法加入了这个概念  A^k(i,j)：表示从i到j中途不经过索引比k大的点的最短路径。

    这个限制的重要之处在于，它将最短路径的概念做了限制，使得该限制有机会满足迭代关系，这个迭代关系就在于研究：假设A^k(i,j)已知，是否可以借此推导出A^k-1(i,j)。

    假设我现在要得到A^k(i,j)，而此时A^k(i,j)已知，那么我可以分两种情况来看待问题：1. A^k(i,j)沿途经过点k；2. A^k(i,j)不经过点k。如果经过点k，那么很显然，A^k(i,j) = A^k-1(i,k) + A^k-1(k,j)，为什么是A^k-1呢？因为对(i,k)和(k,j)，由于k本身就是源点（或者说终点），加上我们求的是A^k(i,j)，所以满足不经过比k大的点的条件限制，且已经不会经过点k，故得出了A^k-1这个值。那么遇到第二种情况，A^k(i,j)不经过点k时，由于没有经过点k，所以根据概念，可以得出A^k(i,j)=A^k-1(i,j)。现在，我们确信有且只有这两种情况---不是经过点k，就是不经过点k，没有第三种情况了，条件很完整，那么是选择哪一个呢？很简单，求的是最短路径，当然是哪个最短，求取哪个，故得出式子：

    A^k(i,j) = min( A^k-1(i,j), A^k-1(i,k) + A^k-1(k,j) )

    现在已经得出了A^k(i,j) = A^k-1(i,k) + A^k-1(k,j)这个递归式，但显然该递归还没有一个出口，也就是说，必须定义一个初始状态，事实上，这个初始状态取决于索引k是从0开始还是从1开始，上面的代码是C写的，是以0为开始索引，但一般描述算法似乎习惯用1做开始索引，如果是以1为开始索引，那么初始状态值应设置为A⁰了，A⁰(i,j)的含义不难理解，即从i到j的边的距离。也就是说，A⁰(i,j) = cost(i,j) 。由于存在i到j不存在边的情况，也就是说，在这种情况下，cost(i,j)无限大，故A⁰(i,j) = oo（当i到j无边时）

    到这里，已经列出了求取A^k(i,j)的整个算法了，但是，最终的目标是求dist(i,j)，即i到j的最短路径，如何把A^k(i,j)转换为dist(i,j)？这个其实很简单，当k=n（n表示索引的个数）的时候，即是说，Aⁿ(i,j)=dist(i,j)。那是因为当k已经最大时，已经不存在索引比k大的点了，那这时候的Aⁿ(i,j)其实就已经是i到j的最短路径了。

代码（不保存路径）：

#include <stdio.h>
#define INF 0xfffffff
#define N 220

int map[N][N];
int CityNum, RoadNum;

void Init(){								// 初始化 
	for(int i = 0; i < CityNum; i ++){
		for(int j = 0; j < CityNum; j++){
			map[i][j] = ( i == j ? 0 : INF );
		}
	}
}

void Floyd(){
	for(int k = 0; k < CityNum; k ++){				//K为中间点 
		for(int i = 0; i < CityNum; i ++){
			for(int j = 0; j < CityNum; j ++){
				if(map[i][k]!=EOF && map[k][j]!=EOF && map[i][j] > map[i][k] + map[k][j]){
					map[i][j] = map[i][k] + map[k][j];// 找中间点，DP思想 
				}
			}
		}
	}
}

int main()
{
	int start, end, len;
	while(scanf("%d%d", &CityNum, &RoadNum) != EOF){
		Init();													// 初始化 
		
		for(int i = 0; i < RoadNum; i ++){				// 建无向图 
			scanf("%d%d%d", &start, &end, &len);
			if(len < map[start][end]){
				map[start][end] = map[end][start] = len;
			}
		}
		scanf("%d%d", &start, &end);
		
		Floyd();
		
		if(map[start][end] == INF){
			printf("-1\n");
		}
		else{
			printf("%d\n", map[start][end]);
		}
	}
} 

如果需要保存最短路径，需要借助path数组：

其中我们用 path 数组记录 经过路径 其实 path 的定义如下  path[i][j]  = k 表示 是最短路径 i-……j  和 j 的直接 前驱  为 k 即是： i-->...............-->k ->j

代码（保存路径）：

#include <stdio.h>
#define INF 0xfffffff
#define N 220

int map[N][N];
int path[N][N];
int Pa[N];
int CityNum, RoadNum;

void Init(){								// 初始化 
	for(int i = 0; i < CityNum; i ++){
		for(int j = 0; j < CityNum; j++){
			map[i][j] = ( i == j ? 0 : INF );
			path[i][j] = (i == j ? i : -1);
		}
	}
}

void Floyd(){
	for(int k = 0; k < CityNum; k ++){				//K为中间点 
		for(int i = 0; i < CityNum; i ++){
			for(int j = 0; j < CityNum; j ++){
				if(map[i][k]!=EOF && map[k][j]!=EOF && map[i][j]>map[i][k]+map[k][j]){
					map[i][j] = map[i][k] + map[k][j];// 找中间点，DP思想 
					path[i][j] = path[k][j];
				}
			}
		}
	}
}
void displaypath(int start, int end){
	int i = 0, tmp = end;
	while(tmp != start){
		Pa[i++] = tmp;
		tmp = path[start][tmp];
	}
	Pa[i++] = start;
	for(int j = i - 1; j >= 0; j--)
		printf("%d ", Pa[j]);
	puts("");
}
int main()
{
	int start, end, len;
	while(scanf("%d%d", &CityNum, &RoadNum) != EOF){
		Init();											// 初始化 
		
		for(int i = 0; i < RoadNum; i ++){				// 建无向图 
			scanf("%d%d%d", &start, &end, &len);
			if(len < map[start][end]){
				map[start][end] = map[end][start] = len;
				path[start][end] = start;
				path[end][start] = end;
			}
		}
		scanf("%d%d", &start, &end);
		
		Floyd();
		
		if(map[start][end] == INF){
			printf("-1\n");
		}
		else{
			printf("%d\n", map[start][end]);
			displaypath(start, end);
		}
	}
}