Floyd-Warshall

Floyd-Warshall算法，简称Floyd算法，用于求解任意两点间的最短距离，时间复杂度为O(n^3)。

 

使用条件&范围

通常可以在任何图中使用，包括有向图、带负权边的图。

 

Floyd-Warshall 算法用来找出每对点之间的最短距离。它需要用邻接矩阵来储存边，这个算法通过考虑最佳子路径来得到最佳路径。

 

1.注意单独一条边的路径也不一定是最佳路径。

2.从任意一条单边路径开始。所有两点之间的距离是边的权，或者无穷大，如果两点之间没有边相连。

对于每一对顶点 u 和 v，看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比己知的路径更短。如果是更新它。

3.不可思议的是，只要按排适当，就能得到结果。

伪代码:

 

 

 //dist(i,j) 为从节点i到节点j的最短距离

For i←1 to n do

  For j←1 to n do

     dist(i,j) = weight(i,j)

 

For k←1 to n do // k为“媒介节点”

  For i←1 to n do

     For j←1 to n do

        if (dist(i,k) + dist(k,j) < dist(i,j)) then // 是否是更短的路径？

           dist(i,j) = dist(i,k) + dist(k,j)

 

我们平时所见的Floyd算法的一般形式如下：

 

 

 voidFloyd(){

    int i,j,k;

    for(k=1;k<=n;k++)

        for(i=1;i<=n;i++)

            for(j=1;j<=n;j++)

                if(dist[i][k]+dist[k][j]<dist[i][j])

                     dist[i][j]=dist[i][k]+dist[k][j];

}

 

注意下第6行这个地方，如果dist[i][k]或者dist[k][j]不存在，程序中用一个很大的数代替。最好写成if(dist[i] [k]!=INF && dist[k][j]!=INF &&dist[i][k]+dist[k][j]

 

Floyd算法的实现以及输出最短路径和最短路径长度，具体过程请看【动画演示Floyd算法】。

 

代码说明几点：

 

1、A[][]数组初始化为各顶点间的原本距离，最后存储各顶点间的最短距离。

 

2、path[][]数组保存最短路径，与当前迭代的次数有关。初始化都为-1，表示没有中间顶点。在求A[i][j]过程中，path[i][j]存放从顶点vi到顶点vj的中间顶点编号不大于k的最短路径上前一个结点的编号。在算法结束时，由二维数组path的值回溯，可以得到从顶点vi到顶点vj的最短路径。

 

初始化A[][]数组为如下，即有向图的邻接矩阵。

POJ2253-Frogger

 

题目大意:

给出两只青蛙的坐标A、B，和其他的n-2个坐标，任一两个坐标点间都是双向连通的。显然从A到B存在至少一条的通路，每一条通路的元素都是这条通路中前后两个点的距离，这些距离中又有一个最大距离。

现在要求求出所有通路的最大距离，并把这些最大距离作比较，把最小的一个最大距离作为青蛙的最小跳远距离。

 

Floyd算法

用Floyd算法求出两两最短路，再求出从每个点开始的最长路，最后从这n个最长路中求出最小的那个即为所求。

#include<iostream>

#include<math.h>

#include<iomanip>

using namespace std;



class coordinate

{

public:

	double x,y;

}point[201];



double path[201][201];   //两点间的权值



int main(void)

{

	int i,j,k;



	int cases=1;

	while(cases)

	{

		/*Read in*/



		int n;   //numbers of stones;

		cin>>n;

		if(!n)break;



		for(i=1;i<=n;i++)

			cin>>point[i].x>>point[i].y;



		/*Compute the weights of any two points*/



		for(i=1;i<=n-1;i++)

			for(j=i+1;j<=n;j++)

			{

				double x2=point[i].x-point[j].x;

				double y2=point[i].y-point[j].y;

				path[i][j]=path[j][i]=sqrt(x2*x2+y2*y2);  //双向性

			}



		/*Floyd Algorithm*/



		for(k=1;k<=n;k++)    //k点是第3点

			for(i=1;i<=n-1;i++)    //主要针对由i到j的松弛,最终任意两点间的权值都会被分别松弛为最大跳的最小（但每个两点的最小不一定相同）

				for(j=i+1;j<=n;j++)

					if(path[i][k]<path[i][j] && path[k][j]<path[i][j])    //当边ik,kj的权值都小于ij时，则走i->k->j路线，否则走i->j路线

						if(path[i][k]<path[k][j])               //当走i->k->j路线时，选择max{ik,kj},只有选择最大跳才能保证连通

							path[i][j]=path[j][i]=path[k][j];

						else

							path[i][j]=path[j][i]=path[i][k];



		cout<<"Scenario #"<<cases++<<endl;

		cout<<fixed<<setprecision(3)<<"Frog Distance = "<<path[1][2]<<endl;

		//fixed用固定的小数点位数来显示浮点数（包括小数位全为0)

		//setprecision(3)设置小数位数为3

		cout<<endl;

	}

	return 0;

}