只有5行的Floyd算法！！！

只有5行的Floyd算法！！！

       上图中有4个城市8条公路，公路上的数字表示这条公路的长短。请注意这些公路是单向的。我们现在需要求任意两个城市之间的最短路程，也就是求任意两个点之间的最短路径。这个问题这也被称为“多源最短路径”问题。

       现在需要一个数据结构来存储图的信息，我们仍然可以用一个4*4的矩阵（二维数组e）来存储。比如1号城市到2号城市的路程为2，则设e[1][2]的值为2。2号城市无法到达4号城市，则设置e[2][4]的值为∞。另外此处约定一个城市自己是到自己的也是0，例如e[1][1]为0，具体如下。

       现在回到问题：如何求任意两点之间最短路径呢？通过之前的学习我们知道通过深度或广度优先搜索可以求出两点之间的最短路径。所以进行n2遍深度或广度优先搜索，即对每两个点都进行一次深度或广度优先搜索，便可以求得任意两点之间的最短路径。可是还有没有别的方法呢？

       我们来想一想，根据我们以往的经验，如果要让任意两点（例如从顶点a点到顶点b）之间的路程变短，只能引入第三个点（顶点k），并通过这个顶点k中转即a->k->b，才可能缩短原来从顶点a点到顶点b的路程。那么这个中转的顶点k是1~n中的哪个点呢？甚至有时候不只通过一个点，而是经过两个点或者更多点中转会更短，即a->k1->k2b->或者a->k1->k2…->k->i…->b。比如上图中从4号城市到3号城市（4->3）的路程e[4][3]原本是12。如果只通过1号城市中转（4->1->3），路程将缩短为11（e[4][1]+e[1][3]=5+6=11）。其实1号城市到3号城市也可以通过2号城市中转，使得1号到3号城市的路程缩短为5（e[1][2]+e[2][3]=2+3=5）。所以如果同时经过1号和2号两个城市中转的话，从4号城市到3号城市的路程会进一步缩短为10。通过这个的例子，我们发现每个顶点都有可能使得另外两个顶点之间的路程变短。好，下面我们将这个问题一般化。

       当任意两点之间不允许经过第三个点时，这些城市之间最短路程就是初始路程，如下。

       如现在只允许经过1号顶点，求任意两点之间的最短路程，应该如何求呢？只需判断e[i][1]+e[1][j]是否比e[i][j]要小即可。e[i][j]表示的是从i号顶点到j号顶点之间的路程。e[i][1]+e[1][j]表示的是从i号顶点先到1号顶点，再从1号顶点到j号顶点的路程之和。其中i是1~n循环，j也是1~n循环，代码实现如下。

1 2 3 4 5 6 7 8

for(i=1;i<=n;i++) {     for(j=1;j<=n;j++)     {         if ( e[i][j] > e[i][1]+e[1][j] )               e[i][j] = e[i][1]+e[1][j];     } }

  在只允许经过1号顶点的情况下，任意两点之间的最短路程更新为：

       通过上图我们发现：在只通过1号顶点中转的情况下，3号顶点到2号顶点（e[3][2]）、4号顶点到2号顶点（e[4][2]）以及4号顶点到3号顶点（e[4][3]）的路程都变短了。

       接下来继续求在只允许经过1和2号两个顶点的情况下任意两点之间的最短路程。如何做呢？我们需要在只允许经过1号顶点时任意两点的最短路程的结果下，再判断如果经过2号顶点是否可以使得i号顶点到j号顶点之间的路程变得更短。即判断e[i][2]+e[2][j]是否比e[i][j]要小，代码实现为如下。

1 2 3 4 5 6 7 8

//经过1号顶点 for(i=1;i<=n;i++)     for(j=1;j<=n;j++)         if (e[i][j] > e[i][1]+e[1][j])  e[i][j]=e[i][1]+e[1][j]; //经过2号顶点 for(i=1;i<=n;i++)     for(j=1;j<=n;j++)         if (e[i][j] > e[i][2]+e[2][j])  e[i][j]=e[i][2]+e[2][j];

        在只允许经过1和2号顶点的情况下，任意两点之间的最短路程更新为：

       通过上图得知，在相比只允许通过1号顶点进行中转的情况下，这里允许通过1和2号顶点进行中转，使得e[1][3]和e[4][3]的路程变得更短了。

       同理，继续在只允许经过1、2和3号顶点进行中转的情况下，求任意两点之间的最短路程。任意两点之间的最短路程更新为：

       最后允许通过所有顶点作为中转，任意两点之间最终的最短路程为：

       整个算法过程虽然说起来很麻烦，但是代码实现却非常简单，核心代码只有五行：

1 2 3 4 5

for(k=1;k<=n;k++)     for(i=1;i<=n;i++)         for(j=1;j<=n;j++)             if(e[i][j]>e[i][k]+e[k][j])                  e[i][j]=e[i][k]+e[k][j];

Floyd算法核心思想总结

1.初始化邻接矩阵；

2.寻找中继点，更新邻接矩阵；

通过这种方法我们可以求出任意两个点之间最短路径。它的时间复杂度是O(N³)。令人很震撼的是它竟然只有五行代码，实现起来非常容易。正是因为它实现起来非常容易，如果时间复杂度要求不高，使用Floyd-Warshall来求指定两点之间的最短路或者指定一个点到其余各个顶点的最短路径也是可行的。当然也有更快的算法，请看下一节：Dijkstra算法。另外需要注意的是：Floyd-Warshall算法不能解决带有“负权回路”（或者叫“负权环”）的图，因为带有“负权回路”的图没有最短路。

Floyd例题（HDU 1874）

畅通工程续

Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 44938    Accepted Submission(s): 16671

Problem Description

某省自从实行了很多年的畅通工程计划后，终于修建了很多路。不过路多了也不好，每次要从一个城镇到另一个城镇时，都有许多种道路方案可以选择，而某些方案要比另一些方案行走的距离要短很多。这让行人很困扰。

现在，已知起点和终点，请你计算出要从起点到终点，最短需要行走多少距离。

 

Input

本题目包含多组数据，请处理到文件结束。
每组数据第一行包含两个正整数N和M(0<N<200,0<M<1000)，分别代表现有城镇的数目和已修建的道路的数目。城镇分别以0～N-1编号。
接下来是M行道路信息。每一行有三个整数A,B,X(0<=A,B<N,A!=B,0<X<10000),表示城镇A和城镇B之间有一条长度为X的双向道路。
再接下一行有两个整数S,T(0<=S,T<N)，分别代表起点和终点。

 

Output

对于每组数据，请在一行里输出最短需要行走的距离。如果不存在从S到T的路线，就输出-1.

 

Sample Input

3 3
0 1 1
0 2 3
1 2 1
0 2
3 1
0 1 1
1 2

 

Sample Output

2
-1

#include <iostream>
#include <cstring>
#include <cstdio>
#define N 201
#define INF 10000
using namespace std;
int main(int argc, char *argv[]) {
	int e[N][N];
	int i,j,k,n,m,x,y,v;
	int s,t;
	
	//scanf n(point num) and m(edge num)
	while(scanf("%d %d",&n,&m)!=EOF){
		//init
		memset(e,INF,sizeof(e));
		for(i=0;i<n;i++)
			e[i][i]=0;
			
		//input		
		for(i=1;i<=m;i++){
			scanf("%d %d %d",&x,&y,&v);
			if(e[x][y]>v) //注意细节，两个城市之间会存在一条及以上道路。不考虑这个问题，AC不了。
			e[x][y]=e[y][x]=v;
		}

		//the core code of Floyd algorithm
		for(k=0;k<n;k++)
			for(i=0;i<n;i++)
				for(j=0;j<n;j++)
					if(e[i][j]>e[i][k]+e[k][j])
						e[i][j]=e[j][i]=e[i][k]+e[k][j];

		//output
		scanf("%d %d",&s,&t);
		if(e[s][t]>=INF){
			printf("-1\n");	
		}else{
			printf("%d\n",e[s][t]);	
		} 
		
	}
	return 0;
}