Floyd算法

Floyd算法是一种动态规划算法，用于求解有向图中每对顶点间的最短路径。它要求有向图中可以有负权值，但是不能有负的回路，和Dijkstra，Bellman-Ford算法一样，都是不能有负回路的。

设有向图G=(V,E)，采用邻接矩阵来表示每对顶点之间的距离d[i][j]。初始时，若i=j，则d[i][j]=0；若i和j之间直接相连,则d[i][j]=Weight(i,j)；若i和j之间不直接相连，则d[i][j]=正无穷 OR INT_MAX。

假设节点编号是1,2,3,,,,,,,n

现在要计算顶点<i,j>之间的最短路径，设<i,j>之间最短路径的中间节点的最大节点是k，即中间节点在(1,2,3,,,,k)的范围内，那么现在有2中情况

1。假设k是<i,j>最短路径的中间节点，那么<i,j>可以划分为<i,k>和<k,j>，因为<i,j>的中间节点在(1,2,3,,,,k)之间，并且最短路径是一条简单路径(节点没有重复的路径)，那么可以得出路径<i,k>和路径<k,j>的中间节点都在(1,2,3,,,,k-1)范围内，所以有d[i][j]=d[i][k]+d[k][j]并且k>=1&&k<=n

2。假设k不是<i,j>最短路径的中间节点，那么<i,j>的中间节点的范围是(1,2,3,,,,,k-1)，那么k时的d[i][j]等于k-1时的d[i][j]

所以，可以得到d[i][j]的值  

当k=0时，d[i][j](k=0)=Weight(i,j)

当k>=1时,d[i][j](k)=min(d[i][j](k-1)，d[i][k](k-1)+d[k][j](k-1))

所以，在初始化d[i][j]之后，就可以用下面的O(n^3)的算法来表示oyd算法

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

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

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

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

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

给定1个有向无负回路图，有10个节点，下面是Floyd算法的具体实现

#include<iostream>
#include<climits>
using namespace std;

#define N 11

int dis[N][N];
int map[N][N];
int path[N][N];

void init(void)
{
	int i,j;

	for(i=1;i<N;i++)
		for(j=1;j<N;j++)
			if(i==j) map[i][j]=0;
			else		 map[i][j]=INT_MAX;

	map[1][2]=2,map[1][4]=20,map[2][5]=1;
	map[3][1]=3,map[4][3]=8,map[4][6]=6;
	map[4][7]=4,map[5][3]=7,map[5][8]=3;
	map[6][3]=1,map[7][8]=1,map[8][6]=2;
	map[8][10]=2,map[9][7]=2,map[10][9]=1;
}

void floyd(void)
{
	int i,j,k;
	
	for(i=1;i<N;i++)
		for(j=1;j<N;j++)
		{
			dis[i][j]=map[i][j];	
			path[i][j]=0;
		}

	for(k=1;k<N;k++)
		for(i=1;i<N;i++)
			for(j=1;j<N;j++)
				if(dis[i][k]!=INT_MAX && dis[k][j]!=INT_MAX && (dis[i][k]+dis[k][j]<dis[i][j]))
				{
					dis[i][j]=dis[i][k]+dis[k][j];
					path[i][j]=k;
				}
}

void print(void)
{
	int i,j;
	for(i=1;i<N;i++)
	{
		for(j=1;j<N;j++)
			cout<<dis[i][j]<<" ";
		cout<<endl;
	}
	
}

int main(void)
{
	init();
	floyd();
	print();
	return 0;
}

矩阵打印出每对<i,j>节点的最短路径长度，另还可以根据path打印出<i,j>的路径