弗洛伊德(Froyd)演算法用於求解所有頂點到所有頂點的的最短路徑。時間複雜度為O(n^3).

正如我們所知道的，Floyd演算法用於求最短路徑。Floyd演算法可以說是Warshall演算法的擴充套件，三個for迴圈就可以解決問題，所以它的時間複雜度為O(n^3)。

Floyd演算法的基本思想如下：從任意節點A到任意節點B的最短路徑不外乎2種可能，1是直接從A到B，2是從A經過若干個節點X到B。所以，我們假設Dis(AB)為節點A到節點B的最短路徑的距離，對於每一個節點X，我們檢查Dis(AX) + Dis(XB) < Dis(AB)是否成立，如果成立，證明從A到X再到B的路徑比A直接到

很簡單吧，程式碼看起來可能像下面這樣： 

for ( int i = 0; i < 節點個數; ++i )
{
	for ( int j = 0; j < 節點個數; ++j )
	{
		for ( int k = 0; k < 節點個數; ++k )
		{
			if ( Dis[i][k] + Dis[k][j] < Dis[i][j] )
			{
				// 找到更短路徑
				Dis[i][j] = Dis[i][k] + Dis[k][j];
			}
		}
	}
}
 

但是這裡我們要注意迴圈的巢狀順序，如果把檢查所有節點X放在最內層，那麼結果將是不正確的，為什麼呢？因為這樣便過早的把i到j的最短路徑確定下來了，而當後面存在更短的路徑時，已經不再會更新了。

讓我們來看一個例子，看下圖：

圖中紅色的數字代表邊的權重。如果我們在最內層檢查所有節點X，那麼對於A->B，我們只能發現一條路徑，就是A->B，路徑距離為9。而這顯然是不正確的，真實的最短路徑是A->D->C->B，路徑距離為6。造成錯誤的原因就是我們把檢查所有節點X放在最內層，造成過早的把A到B的最短路徑確定下來了，當確定A->B的最短路徑時Dis(AC)尚未被計算。所以，我們需要改寫迴圈順序，如下：

for ( int k = 0; k < 節點個數; ++k )
{
	for ( int i = 0; i < 節點個數; ++i )
	{
		for ( int j = 0; j < 節點個數; ++j )
		{
			if ( Dis[i][k] + Dis[k][j] < Dis[i][j] )
			{
				// 找到更短路徑
				Dis[i][j] = Dis[i][k] + Dis[k][j];
			}
		}
	}
}

如果還是看不懂，那就用草稿紙模擬一遍，之後你就會豁然開朗。半個小時足矣（早知道的話會節省很多個半小時了。。）

如果是i-j-k這樣的情況吧。舉個例子：

如果我們現在要更新的1-4的最短距離，要列舉經過的城市個數，有0,1,2,3,4,5種情況，假如現在2-3城市的最短距離為10，當經過的城市為2時候，發現2-3的最短距離為10，可能比其他大了，所以經過2個城市的最小距離可能為8，上面6種情況更新後發現1-4最短距離為13.

當繼續更新時，我們更新後2-3的最短距離竟然為1，但是我們再也回不到1-4這種情況了。。。所以，1-4的最短距離明顯就是錯誤的。

而如果迴圈的順序為：k-i-j的時候：

我們更新1-4的時候，2-3可能沒更新，但是1-4可以更新k次，即使不是最短的，以後再更新到的時候就可以更新為最短了。所以這種才是正確的方法。

這樣一來，對於每一個節點X，我們都會把所有的i到j處理完畢後才繼續檢查下一個節點。

那麼接下來的問題就是，我們如何找出最短路徑呢？這裡需要藉助一個輔助陣列Path，它是這樣使用的：Path(AB)的值如果為P，則表示A節點到B節點的最短路徑是A->...->P->B。這樣一來，假設我們要找A->B的最短路徑，那麼就依次查詢，假設Path(AB)的值為P，那麼接著查詢Path(AP)，假設Path(AP)的值為L，那麼接著查詢Path(AL)，假設Path(AL)的值為A，則查詢結束，最短路徑為A->L->P->B。

那麼，如何填充Path的值呢？很簡單，當我們發現Dis(AX) + Dis(XB) < Dis(AB)成立時，就要把最短路徑改為A->...->X->...->B，而此時，Path(XB)的值是已知的，所以，Path(AB) = Path(XB)。

測試程式碼如下：

#include<cstdio>
#include<cmath>
#include<cstring>
#include<string>
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
using namespace std;
#define INFINITE 1000			// 最大值
#define MAX_VERTEX_COUNT 20// 最大頂點個數
//////////////////////////////////////////////////////////////////////////

struct Graph
{
	int		arrArcs[MAX_VERTEX_COUNT][MAX_VERTEX_COUNT];	// 鄰接矩陣
	int		nVertexCount;								// 頂點數量
	int		nArcCount;									// 邊的數量
};
//////////////////////////////////////////////////////////////////////////

void readGraphData( Graph *_pGraph )
{
	std::cout << "請輸入頂點數量和邊的數量: ";
	std::cin >> _pGraph->nVertexCount;
	std::cin >> _pGraph->nArcCount;

	std::cout << "請輸入鄰接矩陣資料:" << std::endl;
	for ( int row = 0; row < _pGraph->nVertexCount; ++row )
	{
		for ( int col = 0; col < _pGraph->nVertexCount; ++col )
		{
			std::cin >> _pGraph->arrArcs[row][col];
		}
	}
}

void floyd( int _arrDis[][MAX_VERTEX_COUNT], int _arrPath[][MAX_VERTEX_COUNT], int _nVertexCount )
{
	// 先初始化_arrPath
	for ( int i = 0; i < _nVertexCount; ++i )
	{
		for ( int j = 0; j < _nVertexCount; ++j )
		{
			_arrPath[i][j] = i;
		}
	}
	//////////////////////////////////////////////////////////////////////////

	for ( int k = 0; k < _nVertexCount; ++k )
	{
		for ( int i = 0; i < _nVertexCount; ++i )
		{
			for ( int j = 0; j < _nVertexCount; ++j )
			{
				if ( _arrDis[i][k] + _arrDis[k][j] < _arrDis[i][j] )
				{
					// 找到更短路徑
					_arrDis[i][j] = _arrDis[i][k] + _arrDis[k][j];

					_arrPath[i][j] = _arrPath[k][j];
				}
			}
		}
	}
}

void printResult( int _arrDis[][MAX_VERTEX_COUNT], int _arrPath[][MAX_VERTEX_COUNT], int _nVertexCount )
{
	std::cout << "Origin -> Dest	Distance	Path" << std::endl;

	for ( int i = 0; i < _nVertexCount; ++i )
	{
		for ( int j = 0; j < _nVertexCount; ++j )
		{
			if ( i != j )	// 節點不是自身
			{
				std::cout << i+1 << " -> " << j+1 << "\t\t";
				if ( INFINITE == _arrDis[i][j] )	// i -> j 不存在路徑
				{
					std::cout << "INFINITE" << "\t\t";
				}
				else
				{
					std::cout << _arrDis[i][j] << "\t\t";

					// 由於我們查詢最短路徑是從後往前插，因此我們把查詢得到的節點
					// 壓入棧中，最後彈出以順序輸出結果。
					std::stack<int> stackVertices;
					int k = j;
					
					do 
					{
						k = _arrPath[i][k];
						stackVertices.push( k );
					} while ( k != i );
					//////////////////////////////////////////////////////////////////////////

					std::cout << stackVertices.top()+1;
					stackVertices.pop();

					unsigned int nLength = stackVertices.size();
					for ( unsigned int nIndex = 0; nIndex < nLength; ++nIndex )
					{
						std::cout << " -> " << stackVertices.top()+1;
						stackVertices.pop();
					}

					std::cout << " -> " << j+1 << std::endl;
				}
			}
		}
	}
}

int main()
{
	Graph myGraph;
	readGraphData( &myGraph );
	//////////////////////////////////////////////////////////////////////////

	int arrDis[MAX_VERTEX_COUNT][MAX_VERTEX_COUNT];
	int arrPath[MAX_VERTEX_COUNT][MAX_VERTEX_COUNT];

	// 先初始化arrDis
	for ( int i = 0; i < myGraph.nVertexCount; ++i )
	{
		for ( int j = 0; j < myGraph.nVertexCount; ++j )
		{
			arrDis[i][j] = myGraph.arrArcs[i][j];
		}
	}

	floyd( arrDis, arrPath, myGraph.nVertexCount );
	//////////////////////////////////////////////////////////////////////////

	printResult( arrDis, arrPath, myGraph.nVertexCount );
	//////////////////////////////////////////////////////////////////////////

	return 0;
}

轉自：