弗洛伊德算法解析

弗洛伊德算法是求解圖的多源最短路徑的。具有重疊子問題結構爲：

 

Floyd-Warshall算法（Floyd-Warshall algorithm）是解決任意兩點間的最短路徑的一種算法，可以正確處理有向圖或負權的最短路徑問題。

Floyd-Warshall算法的時間複雜度爲O(N³)，空間複雜度爲O(N²)。

原理： 

Floyd-Warshall算法的原理是動態規劃。

設D_i,j,k爲從i到j的只以(1..k)集合中的節點爲中間節點的最短路徑的長度。

1. 若最短路徑經過點k，則D_i,j,k = D_{i,k,k − 1} + D_{k,j,k − 1}；
2. 若最短路徑不經過點k，則D_i,j,k = D_{i,j,k − 1}。

因此，D_i,j,k = min(D_{i,k,k − 1} + D_{k,j,k − 1},D_{i,j,k − 1})。

算法描述：

for k ← 1 to n do
  for i ← 1 to n do
    for j ← 1 to n do
      if (Di,k + Dk,j < Di,j) then
        Di,j ← Di,k + Dk,j; 

案例：

親測代碼：

<span style="font-size:14px;">#include<stdio.h>
#include<string.h>
#include<iostream>
#include<stdlib.h>
using namespace std;
#define maxSize 10
#define INF 1000000
typedef struct 
{
	int edges[maxSize][maxSize];
	int n;//頂點數 
	int e;//邊數 
}MGraph;
void fylod(MGraph g , int A[][maxSize], int path[][maxSize])
{
	int i,j,k;
	for(i=0;i<g.n;i++)
	{
		for(j=0;j<g.n;j++)
		{
			A[i][j]=g.edges[i][j];
			path[i][j] = -1;
		}
	}
	for(k=0;k<g.n;k++)
	{
		for(i=0;i<g.n;i++)
		{
			for(j=0;j<g.n;j++)
			{
				if(A[i][j]>A[i][k]+A[k][i])
				{
					A[i][j] = A[i][k]+A[k][j];
					path[i][j]=k;
				}
			}
		}
	}	
}
void printPath(int u,int v ,int path[][maxSize])
{
	if(path[u][v]==-1)
	{
		printf("-->%d",v);
	} 
	else
	{
		int mid = path[u][v];
		printPath(u,mid,path);//處理他們之間的中間節點 
		printPath(mid,v,path);//處理他們之間的中間節點 
	}
}
int main()
{
	MGraph G;
	int A[maxSize][maxSize];
	int path[maxSize][maxSize];
	int a,b,s;
	G.n = 4;
	G.e = 8; 
	for(int j=0;j<G.n;j++)
	{
		for(int i=0;i<G.n;i++)
		{
			G.edges[i][j] = INF;
			G.edges[j][i] = INF;
		}
	}
	for(int i=0;i<G.e;i++)
	{
		scanf("%d%d%d",&a,&b,&s);
		G.edges[a][b]=s;
	}
	fylod(G,A,path);
	printf("1-0的最短路徑長度爲：%d\n",A[1][0]);
	printf("經過的路徑爲：1"); 
	printPath(1,0,path); 
	return 0;
}</span>

結果：

時間複雜度：

有算法代碼可知，本算法的主要部分是一個三重循環，去內層循環的操作爲基操作，則基操作執行的次數爲n*n*n,因此時間複雜度爲O(n3);