-
Floyd算法
鎖定
- 中文名
- 弗洛伊德算法
- 外文名
- Floyd(Floyd-Warshall)
- 別 名
- Roy-Warshall算法
- 時間複雜度
- O(n^3)
- 空間複雜度
- O(n^2)
- 作 用
- 求多源最短路徑,求傳遞閉包
Floyd算法簡介
在計算機科學中,Floyd-Warshall算法是一種在具有正或負邊緣權重(但沒有負週期)的加權圖中找到最短路徑的算法。算法的單個執行將找到所有頂點對之間的最短路徑的長度(加權)。 雖然它不返回路徑本身的細節,但是可以通過對算法的簡單修改來重建路徑。 該算法的版本也可用於查找關係R的傳遞閉包,或(與Schulze投票系統相關)在加權圖中所有頂點對之間的最寬路徑。
Floyd-Warshall算法是動態規劃的一個例子,並在1962年由Robert Floyd以其當前公認的形式出版。然而,它基本上與Bernard Roy在1959年先前發表的算法和1962年的Stephen Warshall中找到圖形的傳遞閉包基本相同,並且與Kleene的算法密切相關 在1956年)用於將確定性有限自動機轉換為正則表達式。算法作為三個嵌套for循環的現代公式首先由Peter Ingerman在1962年描述。
Floyd算法核心思路
Floyd算法路徑矩陣
從圖的帶權鄰接矩陣A=[a(i,j)] n×n開始,迭代地進行n次更新,即由矩陣D(0)=A,按一個公式,構造出矩陣D(1);又用同樣地公式由D(1)構造出D(2);……;最後又用同樣的公式由D(n-1)構造出矩陣D(n)。矩陣D(n)的i行j列元素便是i號頂點到j號頂點的最短路徑長度,稱D(n)為圖的距離矩陣,同時還可引入一個後繼節點矩陣path來記錄兩點間的最短路徑。
採用鬆弛技術(鬆弛操作),對在i和j之間的所有其他點進行一次鬆弛。所以時間複雜度為O(n^3);
Floyd算法狀態轉移方程
其狀態轉移方程如下: map[i,j]:=min{map[i,k]+map[k,j],map[i,j]};
map[i,j]表示i到j的最短距離,K是窮舉i,j的斷點,map[n,n]初值應該為0,或者按照題目意思來做。
當然,如果這條路沒有通的話,還必須特殊處理,比如沒有map[i,k]這條路。
Floyd算法算法過程
1,從任意一條單邊路徑開始。所有兩點之間的距離是邊的權,如果兩點之間沒有邊相連,則權為無窮大。
2,對於每一對頂點 u 和 v,看看是否存在一個頂點 w 使得從 u 到 w 再到 v 比已知的路徑更短。如果是更新它。
把圖用鄰接矩陣G表示出來,如果從Vi到Vj有路可達,則G[i][j]=d,d表示該路的長度;否則G[i][j]=無窮大。定義一個矩陣D用來記錄所插入點的信息,D[i][j]表示從Vi到Vj需要經過的點,初始化D[i][j]=j。把各個頂點插入圖中,比較插點後的距離與原來的距離,G[i][j] = min( G[i][j], G[i][k]+G[k][j] ),如果G[i][j]的值變小,則D[i][j]=k。在G中包含有兩點之間最短道路的信息,而在D中則包含了最短通路徑的信息。
比如,要尋找從V5到V1的路徑。根據D,假如D(5,1)=3則説明從V5到V1經過V3,路徑為{V5,V3,V1},如果D(5,3)=3,説明V5與V3直接相連,如果D(3,1)=1,説明V3與V1直接相連。
[4]
Floyd算法時間複雜度與空間複雜度
時間複雜度:O(n^3);
空間複雜度:O(n^2)
Floyd算法優缺點分析
Floyd算法適用於APSP(All Pairs Shortest Paths,多源最短路徑),是一種動態規劃算法,稠密圖效果最佳,邊權可正可負。此算法簡單有效,由於三重循環結構緊湊,對於稠密圖,效率要高於執行|V|次Dijkstra算法,也要高於執行|V|次SPFA算法。
優點:容易理解,可以算出任意兩個節點之間的最短距離,代碼編寫簡單。
Floyd算法算法描述
a) 初始化:D[u,v]=A[u,v]
b) For k:=1 to n
For i:=1 to n
For j:=1 to n
If D[i,j]>D[i,k]+D[k,j] Then
D[i,j]:=D[i,k]+D[k,j];
c) 算法結束:D即為所有點對的最短路徑矩陣
Floyd算法參考代碼
Floyd算法C語言
#include<stdio.h> #include<stdlib.h> #define max 1000000000 int d[1000][1000],path[1000][1000]; int main() { int i,j,k,m,n; int x,y,z; scanf("%d%d",&n,&m); for(i=1;i<=n;i++) for(j=1;j<=n;j++){ d[i][j]=max; path[i][j]=j; } for(i=1;i<=m;i++) { scanf("%d%d%d",&x,&y,&z); d[x][y]=z; d[y][x]=z; } 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]; path[i][j]=path[i][k]; } } for(i=1;i<=n;i++) for(j=1;j<=i;j++) if (i!=j) printf("%d->%d:%d\n",i,j,d[i][j]); int f, en; scanf("%d%d",&f,&en); while (f!=en) { printf("%d->",f); f=path[f][en]; } printf("%d\n",en); return 0; }
Floyd算法C++語言
#include<iostream> #include<vector> using namespace std; const int &INF=100000000; void floyd(vector<vector<int> > &distmap,//可被更新的鄰接矩陣,更新後不能確定原有邊 vector<vector<int> > &path)//路徑上到達該點的中轉點 //福利:這個函數沒有用除INF外的任何全局量,可以直接複製! { const int &NODE=distmap.size();//用鄰接矩陣的大小傳遞頂點個數,減少參數傳遞 path.assign(NODE,vector<int>(NODE,-1));//初始化路徑數組 for(int k=1; k!=NODE; ++k)//對於每一箇中轉點 for(int i=0; i!=NODE; ++i)//枚舉源點 for(int j=0; j!=NODE; ++j)//枚舉終點 if(distmap[i][j]>distmap[i][k]+distmap[k][j])//不滿足三角不等式 { distmap[i][j]=distmap[i][k]+distmap[k][j];//更新 path[i][j]=k;//記錄路徑 } } void print(const int &beg,const int &end, const vector<vector<int> > &path)//傳引用,避免拷貝,不佔用內存空間 //也可以用棧結構先進後出的特性來代替函數遞歸 { if(path[beg][end]>=0) { print(beg,path[beg][end],path); print(path[beg][end],end,path); } else cout<<"->"<<end; } int main() { int n_num,e_num,beg,end;//含義見下 cout<<"(不處理負權迴路)輸入點數、邊數:"; cin>>n_num>>e_num; vector<vector<int> > path, distmap(n_num,vector<int>(n_num,INF));//默認初始化鄰接矩陣 for(int i=0,p,q; i!=e_num; ++i) { cout<<"輸入第"<<i+1<<"條邊的起點、終點、長度(100000000代表無窮大,不聯通):"; cin>>p>>q; cin>>distmap[p][q]; } floyd(distmap,path); cout<<"計算完畢,可以開始查詢,請輸入出發點和終點:"; cin>>beg>>end; cout<<"最短距離為"<<distmap[beg][end]<<",打印路徑:"<<beg; print(beg,end,path); }
Floyd算法Matlab源代碼
function Floyd(w,router_direction,MAX) %w為此圖的距離矩陣 %router_direction為路由類型:0為前向路由;非0為回溯路由 %MAX是數據輸入時的∞的實際值 len=length(w); flag=zeros(1,len); %根據路由類型初始化路由表 R=zeros(len,len); for i=1:len if router_direction==0%前向路由 R(:,i)=ones(len,1)*i; else %回溯路由 R(i,:)=ones(len,1)*i; end R(i,i)=0; end disp(''); disp('w(0)'); dispit(w,0); disp('R(0)'); dispit(R,1); %處理端點有權的問題 for i=1:len tmp=w(i,i)/2; if tmp~=0 w(i,:)=w(i,:)+tmp; w(:,i)=w(:,i)+tmp; flag(i)=1; w(i,i)=0; end end %Floyd算法具體實現過程 for i=1:len for j=1:len if j==i || w(j,i)==MAX continue; end for k=1:len if k==i || w(j,i)==MAX continue; end if w(j,i)+w(i,k)<w(j,k) %Floyd算法核心代碼 w(j,k)=w(j,i)+w(i,k); if router_direction==0%前向路由 R(j,k)=R(j,i); else %回溯路由 R(j,k)=R(i,k); end end end end %顯示每次的計算結果 disp(['w(',num2str(i),')']) dispit(w,0); disp(['R(',num2str(i),')']) dispit(R,1); end %中心和中點的確定 [Center,index]=min(max(w')); disp(['中心是V',num2str(index)]); [Middle,index]=min(sum(w')); disp(['中點是V',num2str(index)]); end function dispit(x,flag) %x:需要顯示的矩陣 %flag:為0時表示顯示w矩陣,非0時表示顯示R矩陣 len=length(x); s=[]; for j=1:len if flag==0 s=[s sprintf('%5.2f\t',x(j,:))]; else s=[s sprintf('%d\t',x(j,:))]; end s=[s sprintf('\n')]; end disp(s); disp('---------------------------------------------------'); end % 選擇後按Ctrl+t取消註釋號% % % 示例: % a=[ % 0,100,100,1.2,9.2,100,0.5; % 100,0,100,5,100,3.1,2; % 100,100,0,100,100,4,1.5; % 1.2,5,100,0,6.7,100,100; % 9.2,100,100,6.7,0,15.6,100; % 100,3.1,4,100,15.6,0,100; % 0.5,2,1.5,100,100,100,0 % ]; % % b=[ % 0,9.2,1.1,3.5,100,100; % 1.3,0,4.7,100,7.2,100; % 2.5,100,0,100,1.8,100; % 100,100,5.3,0,2.4,7.5; % 100,6.4,2.2,8.9,0,5.1; % 7.7,100,2.7,100,2.1,0 % ]; % % Floyd(a,1,100) % Floyd(b,1,100)
Floyd算法pascal語言
program floyd; varst,en,f:integer; k,n,i,j,x:integer; a:array[1..10,1..10] of integer; path:array[1..10,1..10] of integer; begin readln(n); for i:=1 to n do begin for j:=1 to n do begin read(k); if k<>0 thena[i,j]:=k elsea[i,j]:=maxint; path[i,j]:=j; end; readln; end; for x:=1 to n do for i:=1 to n do for j:=1 to n do if a[i,j]>a[i,x]+a[x,j] then begin a[i,j]:=a[i,x]+a[x,j]; path[i,j]:=path[i,x]; end; readln(st,en); writeln(a[st,en]); f:=st; while f<> en do begin write(f); write('-->'); f:=path[f,en]; end; writeln(en); end.
Floyd算法java語言
//以無向圖G為入口,得出任意兩點之間的路徑長度length[i][j],路徑path[i][j][k], //途中無連接得點距離用0表示,點自身也用0表示 public class FLOYD { int[][] length = null;// 任意兩點之間路徑長度 int[][][] path = null;// 任意兩點之間的路徑 public FLOYD(int[][] G) { int MAX = 100;int row = G.length;// 圖G的行數 int[][] spot = new int[row][row];// 定義任意兩點之間經過的點 int[] onePath = new int[row];// 記錄一條路徑 length = new int[row][row]; path = new int[row][row][]; for (int i = 0; i < row; i++)// 處理圖兩點之間的路徑 for (int j = 0; j < row; j++) { if (G[i][j] == 0)G[i][j] = MAX;// 沒有路徑的兩個點之間的路徑為默認最大 if (i == j)G[i][j] = 0;// 本身的路徑長度為0 } for (int i = 0; i < row; i++)// 初始化為任意兩點之間沒有路徑 for (int j = 0; j < row; j++) spot[i][j] = -1; for (int i = 0; i < row; i++)// 假設任意兩點之間的沒有路徑 onePath[i] = -1; for (int v = 0; v < row; ++v) for (int w = 0; w < row; ++w) length[v][w] = G[v][w]; for (int u = 0; u < row; ++u) for (int v = 0; v < row; ++v) for (int w = 0; w < row; ++w) if (length[v][w] > length[v][u] + length[u][w]) { length[v][w] = length[v][u] + length[u][w];// 如果存在更短路徑則取更短路徑 spot[v][w] = u;// 把經過的點加入 } for (int i = 0; i < row; i++) {// 求出所有的路徑 int[] point = new int[1]; for (int j = 0; j < row; j++) { point[0] = 0; onePath[point[0]++] = i; outputPath(spot, i, j, onePath, point); path[i][j] = new int[point[0]]; for (int s = 0; s < point[0]; s++) path[i][j][s] = onePath[s]; } } } void outputPath(int[][] spot, int i, int j, int[] onePath, int[] point) {// 輸出i// 到j// 的路徑的實際代碼,point[]記錄一條路徑的長度 if (i == j)return; if (spot[i][j] == -1) onePath[point[0]++] = j; // System.out.print(" "+j+" "); else { outputPath(spot, i, spot[i][j], onePath, point); outputPath(spot, spot[i][j], j, onePath, point); } } public static void main(String[] args) { int data[][] = { { 0, 27, 44, 17, 11, 27, 42, 0, 0, 0, 20, 25, 21, 21, 18, 27, 0 },// x1 { 27, 0, 31, 27, 49, 0, 0, 0, 0, 0, 0, 0, 52, 21, 41, 0, 0 },// 1 { 44, 31, 0, 19, 0, 27, 32, 0, 0, 0, 47, 0, 0, 0, 32, 0, 0 },// 2 { 17, 27, 19, 0, 14, 0, 0, 0, 0, 0, 30, 0, 0, 0, 31, 0, 0 },// 3 { 11, 49, 0, 14, 0, 13, 20, 0, 0, 28, 15, 0, 0, 0, 15, 25, 30 },// 4 { 27, 0, 27, 0, 13, 0, 9, 21, 0, 26, 26, 0, 0, 0, 28, 29, 0 },// 5 { 42, 0, 32, 0, 20, 9, 0, 13, 0, 32, 0, 0, 0, 0, 0, 33, 0 },// 6 { 0, 0, 0, 0, 0, 21, 13, 0, 19, 0, 0, 0, 0, 0, 0, 0, 0 },// 7 { 0, 0, 0, 0, 0, 0, 0, 19, 0, 11, 20, 0, 0, 0, 0, 33, 21 },// 8 { 0, 0, 0, 0, 28, 26, 32, 0, 11, 0, 10, 20, 0, 0, 29, 14, 13 },// 9 { 20, 0, 47, 30, 15, 26, 0, 0, 20, 10, 0, 18, 0, 0, 14, 9, 20 },// 10 { 25, 0, 0, 0, 0, 0, 0, 0, 0, 20, 18, 0, 23, 0, 0, 14, 0 },// 11 { 21, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, 27, 22, 0, 0 },// 12 { 21, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 0, 0, 0, 0 },// 13 { 18, 41, 32, 31, 15, 28, 0, 0, 0, 29, 14, 0, 22, 0, 0, 11, 0 },// 14 { 27, 0, 0, 0, 25, 29, 33, 0, 33, 14, 9, 14, 0, 0, 11, 0, 9 },// 15 { 0, 0, 0, 0, 30, 0, 0, 0, 21, 13, 20, 0, 0, 0, 0, 9, 0 } // 16 }; for (int i = 0; i < data.length; i++) for (int j = i; j < data.length; j++) if (data[i][j] != data[j][i])return; FLOYD test=new FLOYD(data); for (int i = 0; i < data.length; i++) for (int j = i; j < data[i].length; j++) { System.out.println(); System.out.print("From " + i + " to " + j + " path is: "); for (int k = 0; k < test.path[i][j].length; k++) System.out.print(test.path[i][j][k] + " "); System.out.println(); System.out.println("From " + i + " to " + j + " length :"+ test.length[i][j]); } } }
- 參考資料
-
- 1. 郝自軍,何尚錄. 最短路問題的Floyd算法的若干討論[J]. 重慶工學院學報(自然科學版),2008,(05):156-159. [2017-09-02].
- 2. Kleene, S. C. (1956). "Representation of events in nerve nets and finite automata". In C. E. Shannon and J. McCarthy. Automata Studies. Princeton University Press. pp. 3–42.
- 3. 石為人,王楷. 基於Floyd算法的移動機器人最短路徑規劃研究[J]. 儀器儀表學報,2009,30(10):2088-2092. [2017-09-02].
- 4. Kenneth H. Rosen (2003). Discrete Mathematics and Its Applications, 5th Edition. Addison Wesley. ISBN 0-07-119881-4.
- 5. Gross, Jonathan L.; Yellen, Jay (2003), Handbook of Graph Theory, Discrete Mathematics and Its Applications, CRC Press, p. 65, ISBN 9780203490204.