- 用來求圖中所有點對之間的最短路徑
- Dijkstra算法是求單源最短路徑的，那如果求圖中所有點對的最短路徑的話則有以下兩種解法：
- 解法一：
以圖中的每個頂點作為源點，調用Dijkstra算法，時間復雜度為O(n3)； - 解法二：
Floyd（弗洛伊德算法）更簡潔，算法復雜度仍為O(n3)。
- 解法一：
- 正如大多數教材中所講到的，求單源點無負邊最短路徑用Dijkstra，而求所有點最短路徑用Floyd。確實，我們將用到Floyd算法，但是，并不是說所有情況下Floyd都是最佳選擇。
- 對于沒有學過Floyd的人來說，在掌握了Dijkstra之后遇到All-Pairs最短路徑問題的第一反應可能會是：計算所有點的單源點最短路徑，不就可以得到所有點的最短路徑了嗎。簡單得描述一下算法就是執行n次Dijkstra算法。
- Floyd可以說是Warshall算法的擴展了，三個for循環便可以解決一個復雜的問題，應該說是十分經典的。從它的三層循環可以看出，它的復雜度是n3，除了在第二層for中加點判斷可以略微提高效率，幾乎沒有其他辦法再減少它的復雜度。
- 比較兩種算法，不難得出以下的結論：對于稀疏的圖，采用n次Dijkstra比較出色，對于茂密的圖，可以使用Floyd算法。另外，Floyd可以處理帶負邊的圖。
下面對Floyd算法進行介紹：
- Floyd算法的基本思想：
可以將問題分解:
第一、先找出最短的距離
第二、然后在考慮如何找出對應的行進路線。
如何找出最短路徑呢，這里還是用到動態規劃的知識，對于任何一個城市而言，i到j的最短距離不外乎存在經過i與j之間經過k和不經過k兩種可能，所以可以令k=1，2，3，...，n(n是城市的數目)，在檢查d(ij)與d(ik)+d(kj)的值；在此d(ik)與d(kj)分別是目前為止所知道的i到k與k到j的最短距離，因此d(ik)+d(kj)就是i到j經過k的最短距離。所以，若有d(ij)>d(ik)+d(kj)，就表示從i出發經過k再到j的距離要比原來的i到j距離短，自然把i到j的d(ij)重寫為d(ik)+d(kj)，每當一個k查完了，d(ij)就是目前的i到j的最短距離。重復這一過程，最后當查完所有的k時，d(ij)里面存放的就是i到j之間的最短距離了。
Floyd算法的基本步驟：
定義n×n的方陣序列D-1, D0 , … Dn－1,
-
初始化： D-1＝C
- D-1[i][j]＝邊<i,j>的長度，表示初始的從i到j的最短路徑長度，即它是從i到j的中間不經過其他中間點的最短路徑。
-
迭代：設Dk-1已求出，如何得到Dk（0≤k≤n-1）？
- Dk-1[i][j]表示從i到j的中間點不大于k-1的最短路徑p：i…j，
- 考慮將頂點k加入路徑p得到頂點序列q：i…k…j，
- 若q不是路徑，則當前的最短路徑仍是上一步結果：Dk[i][j]= Dk－1[i][j]；
- 否則若q的長度小于p的長度，則用q取代p作為從i到j的最短路徑
因為q的兩條子路徑i…k和k…j皆是中間點不大于k－1的最短路徑，所以從i到j中間點不大于k的最短路徑長度為：
Dk[i][j]＝min{ Dk-1[i][j], Dk-1[i][k] +Dk-1[k][j] }
Floyd算法實現：
可以用三個for循環把問題搞定了，但是有一個問題需要注意，那就是for循環的嵌套的順序：我們可能隨手就會寫出這樣的程序，但是仔細考慮的話，會發現是有問題的。
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
for(int k=0; k<n; k++)問題出在我們太早的把i-k-j的距離確定下來了，假設一旦找到了i-p-j最短的距離后，i到j就相當處理完了，以后不會在改變了，一旦以后有使i到j的更短的距離時也不能再去更新了，所以結果一定是不對的。所以應當象下面一樣來寫程序：
for(int k=0; k<n; k++)
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)這樣做的意義在于固定了k，把所有i到j而經過k的距離找出來，然后象開頭所提到的那樣進行比較和重寫，因為k是在最外層的，所以會把所有的i到j都處理完后，才會移動到下一個k，這樣就不會有問題了，看來多層循環的時候，我們一定要當心，否則很容易就弄錯了。
路徑查找
- 接下來就要看一看如何找出最短路徑所行經的城市了，這里要用到另一個矩陣P，它的定義是這樣的：p(ij)的值如果為p，就表示i到j的最短行經為i->...->p->j，也就是說p是i到j的最短行徑中的j之前的最后一個城市。P矩陣的初值為p(ij)=i。有了這個矩陣之后，要找最短路徑就輕而易舉了。對于i到j而言找出p(ij)，令為p，就知道了路徑i->...->p->j；再去找p(ip)，如果值為q，i到p的最短路徑為i->...->q->p；再去找p(iq)，如果值為r，i到q的最短路徑為i->...->r->q；所以一再反復，到了某個p(it)的值為i時，就表示i到t的最短路徑為i->t，就會的到答案了，i到j的最短行徑為i->t->...->q->p->j。因為上述的算法是從終點到起點的順序找出來的，所以輸出的時候要把它倒過來。
- 但是，如何動態的回填P矩陣的值呢？回想一下，當d(ij)>d(ik)+d(kj)時，就要讓i到j的最短路徑改為走i->...->k->...->j這一條路，但是d(kj)的值是已知的，換句話說，就是k->...->j這條路是已知的，所以k->...->j這條路上j的上一個城市(即p(kj))也是已知的，當然，因為要改走i->...->k->...->j這一條路，j的上一個城市正好是p(kj)。所以一旦發現d(ij)>d(ik)+d(kj)，就把p(kj)存入p(ij)。
小例子
![]()
- 代碼
#include<iostream>
#include<string.h>
using namespace std;
#define len 100
#define INF 999999
class Graph{
// 內部類
private:
// 鄰接表中表對應的鏈表的頂點
class ENode{
public:
int vex; // 頂點
int weight; // 權重
ENode *nextEdge; // 指向下一條弧
};
// 鄰接表中表的頂點
class VNode{
public:
char data; // 頂點信息
ENode *firstEdge; // 指向第一條依付該頂點的弧
};
// 私有成員
private:
int n; // 節點個數
int e; // 邊的個數
VNode mVexs[len];
public:
Graph(){
ENode *node1, *node2;
n = 7;
e = 12;
// 設置節點為默認數值
string nodes = "ABCDEFG";
// 輸入節點
for(int i=0; i < n; i++){
mVexs[i].data = nodes[i];
mVexs[i].firstEdge = NULL;
}
// 設置邊為默認值
char edges[][2] = {
{'A', 'B'},
{'A', 'F'},
{'A', 'G'},
{'B', 'C'},
{'B', 'F'},
{'C', 'D'},
{'C', 'E'},
{'C', 'F'},
{'D', 'E'},
{'E', 'F'},
{'E', 'G'},
{'F', 'G'}
};
// 邊的權重
int weights[len] = {12, 16, 14, 10, 7, 3, 5, 6, 4, 2, 8, 9};
// 初始化鄰接表的邊
for(int i=0; i < e; i++){
int start = get_Node_Index(edges[i][0]);
int end = get_Node_Index(edges[i][1]);
// 初始化 node1
node1 = new ENode();
node1->vex = end;
node1->weight = weights[i];
node1->nextEdge = NULL;
// 將 node 添加到 start 所在鏈表的末尾
if(mVexs[start].firstEdge == NULL){
mVexs[start].firstEdge = node1;
}
else{
linkLast(mVexs[start].firstEdge, node1);
}
// 初始化 node2
node2 = new ENode();
node2->vex = start;
node2->weight = weights[i];
node2->nextEdge = NULL;
// 將 node 添加到 end 所在鏈表的末尾
if(mVexs[end].firstEdge == NULL){
mVexs[end].firstEdge = node2;
}
else{
linkLast(mVexs[end].firstEdge, node2);
}
}
}
// 相鄰節點鏈接子函數
void linkLast(ENode*p1, ENode*p2){
ENode*p = p1;
while(p->nextEdge){
p = p->nextEdge;
}
p->nextEdge = p2;
}
// 返回頂點下標
int get_Node_Index(char number){
for(int i=0; i < n; i++){
if(number == mVexs[i].data){
return i;
}
}
return -1; //這句話永遠不會執行的
}
// 輸出鄰接表
void print(){
for(int i=0; i < n; i ++){
cout<<mVexs[i].data;
ENode *temp = mVexs[i].firstEdge;
while(temp){
cout<<" -> "<<temp->vex;
temp = temp->nextEdge;
}
cout<<endl;
}
cout<<endl;
}
// 得到兩個節點之間的權重
int getWeight(int m, int n){
ENode *enode = mVexs[m].firstEdge;
while(enode){
if(enode->vex == n){
return enode->weight;
}
enode = enode->nextEdge;
}
return INF;
}
// 弗洛伊德算法
void floyd(){
int dist[n][n]; // 距離矩陣
int path[7][7]; // 路徑矩陣, 7為節點數目
int i, j, k;
int temp;
// 初始化權重
for(i = 0; i < n; i++){
for(j = 0; j < n; j++){
if(i == j){
dist[i][j] = 0;
}
else{
dist[i][j] = getWeight(i, j);
}
path[i][j] = i;
}
}
// floyd 算法開始
for(k = 0; k < n; k++){
for(i = 0; i < n; i++){
for(j = 0; j < n; j++){
temp = (dist[i][k] == INF || dist[k][j] == INF)? INF : (dist[i][k] + dist[k][j]);
if(temp < dist[i][j]){
dist[i][j] = temp;
path[i][j] = path[k][j];
}
}
}
}
// 打印出兩點之間最短距離 + 路徑
for(i = 0; i < n-1; i++){
for(j = i+1; j < n; j++){
if(dist[i][j] < 10){
cout<<mVexs[i].data<<" -> "<<mVexs[j].data<<": "<<dist[i][j]<<" , 路徑為: ";
}
else{
cout<<mVexs[i].data<<" -> "<<mVexs[j].data<<": "<<dist[i][j]<<" , 路徑為: ";
}
getPath(i, j, path);
cout<<endl;
}
cout<<endl;
}
// 輸出路徑矩陣觀察, 可用此矩陣自己用筆演算一下路徑查找過程
// for(i = 0; i < n; i++){
// for(j = 0; j < n; j++){
// cout<<path[i][j]<<" ";
// }
// cout<<endl;
// }
}
// 遞歸實現得到節點之間最短路徑
void getPath(int start, int end, int path[][7]){
if(path[start][end] == start){
cout<<mVexs[start].data<<" "<<mVexs[end].data<<" ";
}
else{
getPath(start, path[start][end], path);
cout<<mVexs[end].data<<" ";
}
}
};
int main(){
Graph g;
// 輸出鄰接表
// g.print();
// 弗洛伊德算法
g.floyd();
return 0;
}
