2. 程式人生 > >圖論：圖的四種最短路徑演算法

圖論：圖的四種最短路徑演算法

阿新 • • 發佈：2019-01-01

本文總結了圖的幾種最短路徑演算法的實現：深度或廣度優先搜尋演算法，弗洛伊德演算法，迪傑斯特拉演算法，Bellman-Ford演算法

1），深度或廣度優先搜尋演算法（解決單源最短路徑）
從起始結點開始訪問所有的深度遍歷路徑或廣度優先路徑，則到達終點結點的路徑有多條，取其中路徑權值最短的一條則為最短路徑。

下面是核心程式碼：


void dfs(int cur, int dst){    
    /***operation***/    
    
    /***operation***/    
    if(minPath < dst) return;//當前走過路徑大於之前最短路徑，沒必要再走下去    
    if(cur == n){//臨界條件    
        if(minPath > dst) minPath = dst;    
        return;    
    }    
    else{    
        int i;    
        for(i = 1; i <= n; i++){    
            if(edge[cur][i] != inf && edge[cur][i] != 0 && mark[i] == 0){    
                mark[i] = 1;    
                dfs(i, dst+edge[cur][i]);    
                mark[i] = 0;  //需要在深度遍歷返回時將訪問標誌置0              
            }    
        }    
        return;    
    }    
}
例1：下面是城市的地圖，注意是單向圖，求城市1到城市5的最短距離。(引用的是上次總結的圖論（一）中1）的例2)

/***先輸入n個結點，m條邊，之後輸入有向圖的m條邊，邊的前兩元素表示起始結點，第三個值表權值，輸出1號城市到n號城市的最短距離***/    
/***演算法的思路是訪問所有的深度遍歷路徑，需要在深度遍歷返回時將訪問標誌置0***/    
#include <iostream>    
#include <iomanip>    
#define nmax 110    
#define inf 999999999    
using namespace std;    
int n, m, minPath, edge[nmax][nmax], mark[nmax];//結點數，邊數，最小路徑，鄰接矩陣，結點訪問標記    
void dfs(int cur, int dst){    
    /***operation***/    
    
    /***operation***/    
    if(minPath < dst) return;//當前走過路徑大於之前最短路徑，沒必要再走下去    
    if(cur == n){//臨界條件    
        if(minPath > dst) minPath = dst;    
        return;    
    }    
    else{    
        int i;    
        for(i = 1; i <= n; i++){    
            if(edge[cur][i] != inf && edge[cur][i] != 0 && mark[i] == 0){    
                mark[i] = 1;    
                dfs(i, dst+edge[cur][i]);    
                mark[i] = 0;                
            }    
        }    
        return;    
    }    
}    
    
int main(){    
    while(cin >> n >> m && n != 0){    
        //初始化鄰接矩陣    
        int i, j;    
        for(i = 1; i <= n; i++){    
            for(j = 1; j <= n; j++){    
                edge[i][j] = inf;    
            }    
            edge[i][i] = 0;    
        }    
        int a, b;    
        while(m--){    
            cin >> a >> b;    
            cin >> edge[a][b];    
        }    
        //以dnf(1)為起點開始遞迴遍歷    
        memset(mark, 0, sizeof(mark));    
        minPath = inf;    
        mark[1] = 1;    
        dfs(1, 0);    
        cout << minPath << endl;    
    }    
    return 0;    
}

程式執行結果如下：

2），弗洛伊德演算法（解決多源最短路徑）：時間複雜度O(n^3),空間複雜度O(n^2)
基本思想：最開始只允許經過1號頂點進行中轉，接下來只允許經過1號和2號頂點進行中轉......允許經過1~n號所有頂點進行中轉，來不斷動態更新任意兩點之間的最短路程。即求從i號頂點到j號頂點只經過前k號點的最短路程。

分析如下：1，首先構建鄰接矩陣Floyd[n+1][n+1]，假如現在只允許經過1號結點，求任意兩點間的最短路程，很顯然Floyd[i][j] = min{Floyd[i][j], Floyd[i][1]+Floyd[1][j]}，程式碼如下：

for(i = 1; i <= n; i++){  
    for(j = 1; j <= n; j++){  
        if(Floyd[i][j] > Floyd[i][1] + Floyd[1][j])  
            Floyd[i][j] = Floyd[i][1] + Floyd[1][j];  
    }  
}

2，接下來繼續求在只允許經過1和2號兩個頂點的情況下任意兩點之間的最短距離，在已經實現了從i號頂點到j號頂點只經過前1號點的最短路程的前提下，現在再插入第2號結點，來看看能不能更新更短路徑，故只需在步驟1求得的Floyd[n+1][n+1]基礎上，進行Floyd[i][j] = min{Floyd[i][j], Floyd[i][2]+Floyd[2][j]}；......

3，很顯然，需要n次這樣的更新，表示依次插入了1號，2號......n號結點，最後求得的Floyd[n+1][n+1]是從i號頂點到j號頂點只經過前n號點的最短路程。故核心程式碼如下：

#define inf 99999999  
for(k = 1; k <= n; k++){  
    for(i = 1; i <= n; i++){  
        for(j = 1; j <= n; j++){  
            if(Floyd[i][k] < inf && Floyd[k][j] < inf && Floyd[i][j] > Floyd[i][k] + Floyd[k][j])  
                Floyd[i][j] = Floyd[i][k] + Floyd[k][j];  
        }  
    }  
}

例1：尋找最短的從商店到賽場的路線。其中商店在1號結點處，賽場在n號結點處，1~n結點中有m條線路雙向連線。

/***先輸入n，m，再輸入m個三元組，n為路口數，m表示有幾條路其中1為商店，n為賽場，三元組分別表起點，終點，該路徑長，輸出1到n的最短路徑***/  
#include <iostream>  
using namespace std;  
#define inf 99999999  
#define nmax 110  
int edge[nmax][nmax], n, m;  
int main(){  
    while(cin >> n >> m && n!= 0){  
        //構建鄰接矩陣  
        int i, j;  
        for(i = 1; i <= n; i++){  
            for(j = 1; j <= n; j++){  
                edge[i][j] = inf;  
            }  
            edge[i][i] = 0;  
        }  
        while(m--){  
            cin >> i >> j;  
            cin >> edge[i][j];  
            edge[j][i] = edge[i][j];  
        }  
        //使用弗洛伊德演算法  
        int k;  
        for(k = 1; k <= n; k++){  
            for(i = 1; i <= n; i++){  
                for(j = 1; j <= n; j++){  
                    if(edge[i][k] < inf && edge[k][j] < inf && edge[i][j] > edge[i][k] + edge[k][j])  
                        edge[i][j] = edge[i][k] + edge[k][j];  
                }  
            }  
        }  
        cout << edge[1][n] << endl;  
    }  
    return 0;  
}
程式執行結果如下：


3），迪傑斯特拉演算法（解決單源最短路徑）
基本思想：每次找到離源點（如1號結點）最近的一個頂點，然後以該頂點為中心進行擴充套件，最終得到源點到其餘所有點的最短路徑。
基本步驟：1，設定標記陣列book[]：將所有的頂點分為兩部分,已知最短路徑的頂點集合P和未知最短路徑的頂點集合Q，很顯然最開始集合P只有源點一個頂點。book[i]為1表示在集合P中；
2，設定最短路徑陣列dst[]並不斷更新：初始狀態下，令dst[i] = edge[s][i](s為源點，edge為鄰接矩陣)，很顯然此時dst[s]=0，book[s]=1。此時，在集合Q中可選擇一個離源點s最近的頂點u加入到P中。並依據以u為新的中心點，對每一條邊進行鬆弛操作(鬆弛是指由結點s-->j的途中可以經過點u，並令dst[j]=min{dst[j], dst[u]+edge[u][j]})，並令book[u]=1;
3，在集合Q中再次選擇一個離源點s最近的頂點v加入到P中。並依據v為新的中心點，對每一條邊進行鬆弛操作(即dst[j]=min{dst[j], dst[v]+edge[v][j]}),並令book[v]=1;
4，重複3，直至集合Q為空。
以下是圖示：

核心程式碼如下所示：

#define inf 99999999  
/***構建鄰接矩陣edge[][],且1為源點***/  
for(i = 1; i <= n; i++) dst[i] = edge[1][s]；  
for(i = 1; i <= n; i++) book[i] = 0;  
book[1] = 1;  
for(i = 1; i <= n-1; i++){  
    //找到離源點最近的頂點u，稱它為新中心點  
    min = inf;  
    for(j = 1; j <= n; j++){  
        if(book[j] == 0 && dst[j] < min){  
            min = dst[j];  
            u = j;  
        }  
    }  
    book[u] = 1;  
    //更新最短路徑陣列  
    for(k = 1; k <= n; k++){  
        if(edge[u][k] < inf && book[k] == 0){  
            if(dst[k] > dst[u] + edge[u][k])  
                dst[k] = dst[u] + edge[u][k];             
        }  
    }  
}
例1：給你n個點，m條無向邊，每條邊都有長度d和花費p，給你起點s，終點t，要求輸出起點到終點的最短距離及其花費，如果最短距離有多條路線，則輸出花費最少的。
輸入：輸入n,m，點的編號是1~n,然後是m行，每行4個數 a,b,d,p，表示a和b之間有一條邊，且其長度為d，花費為p。最後一行是兩個數s,t;起點s，終點 t。n和m為 0 時輸入結束。(1<n<=1000, 0<m<100000, s != t)
輸出：輸出一行，有兩個數， 最短距離及其花費。
分析：由於每條邊有長度d和花費p，最好構建邊結構體存放，此外可以使用鄰接連結串列，使用鄰接連結串列時需要將上面的核心程式碼修改幾個地方：

1，初始化dst[]時使用結點1的鄰接連結串列；
2，更新最短路徑陣列時，k的範圍由1~n變為1~edge[u].size()。先採用鄰接矩陣解決此題，再使用鄰接表解決此題，兩種方法的思路都一樣：初始化鄰接矩陣或鄰接連結串列，並
初始化最短路徑陣列dst ----> n-1輪邊的鬆弛中，先找到離新源點最近的中心點u，之後根據中心點u為轉折點來更新路徑陣列。

使用鄰接矩陣求解：

/***對於無向圖，輸入n,m，點的編號是1~n,然後是m行，每行4個數 a,b,d,p，表示a和b之間有一條邊，且其長度為d，花費為p。最後一行是兩個數s,t;起點s，終點 t。***/  
/***n和m為 0 時輸入結束。(1<n<=1000, 0<m<100000, s != t)     輸出：輸出一行，有兩個數， 最短距離及其花費。***/  
#include <iostream>  
#include <iomanip>  
using namespace std;  
#define nmax 1001  
#define inf 99999999  
struct Edge{  
    int len;  
    int cost;  
};  
Edge edge[nmax][nmax];  
int dst[nmax], spend[nmax], book[nmax], n, m, stNode, enNode;  
int main(){  
    while(cin >> n >> m && n != 0 && m != 0){  
        int a, b, i, j;  
        //構建鄰接矩陣和最短路徑陣列  
        for(i = 1; i <= n; i++){  
            for(j = 1; j <= n; j++){  
                edge[i][j].cost = 0;  
                edge[i][j].len = inf;  
            }  
            edge[i][i].len = 0;  
        }  
        while(m--){  
            cin >> a >> b;  
            cin >> edge[a][b].len >> edge[a][b].cost;  
            edge[b][a].len = edge[a][b].len;  
            edge[b][a].cost = edge[a][b].cost;  
        }  
        cin >> stNode >> enNode;  
        for(i = 1; i <= n; i++){  
            dst[i] = edge[stNode][i].len;  
            spend[i] = edge[stNode][i].cost;  
        }  
        memset(book, 0, sizeof(book));  
        book[stNode] = 1;  
        //開始迪傑斯特拉演算法，進行剩餘n-1次鬆弛  
        int k;  
        for(k = 1; k <= n-1; k++){  
            //找離源點最近的頂點u  
            int minNode, min = inf;  
            for(i = 1; i <= n; i++){  
                if(book[i] == 0 && min > dst[i] /* || min == dst[i]&& edge[stNode][min].cost > edge[stNode][i].cost*/){  
                    min = dst[i];  
                    minNode = i;  
                }  
            }  
            //cout << setw(2) << minNode;  
            book[minNode] = 1;//易錯點1，錯寫成book[i]=1  
            //以中心點u為轉折點來更新路徑陣列和花費陣列  
            for(i = 1; i <= n; i++){  
                if(book[i] == 0 && dst[i] > dst[minNode] + edge[minNode][i].len || dst[i] == dst[minNode] + edge[minNode][i].len && spend[i] > spend[minNode] + edge[minNode][i].cost){  
                    dst[i] = dst[minNode] + edge[minNode][i].len;//易錯點2，錯寫成dst[i]+  
                    spend[i] = spend[minNode] + edge[minNode][i].cost;  
                }  
            }  
        }  
        cout << dst[enNode] << setw(3) << spend[enNode] << endl;  
    }  
    return 0;  
}
程式執行結果如下：



使用鄰接連結串列求解：

/***對於無向圖，輸入n,m，點的編號是1~n,然後是m行，每行4個數 a,b,d,p，表示a和b之間有一條邊，且其長度為d，花費為p。最後一行是兩個數s,t;起點s，終點 t。***/  
/***n和m為 0 時輸入結束。(1<n<=1000, 0<m<100000, s != t)     輸出：輸出一行，有兩個數， 最短距離及其花費。***/  
#include <iostream>  
#include <iomanip>  
#include <vector>  
using namespace std;  
#define nmax 1001  
#define inf 99999999  
struct Edge{  
    int len;  
    int cost;  
    int next;  
};  
vector<Edge> edge[nmax];  
int dst[nmax], spend[nmax], book[nmax], n, m, stNode, enNode;  
int main(){  
    while(cin >> n >> m && n != 0 && m != 0){  
        int a, b, i, j;  
        //構建鄰接表和最短路徑陣列  
        for(i = 1; i <= n; i++) edge[i].clear();  
        while(m--){  
            Edge tmp;  
            cin >> a >> b;  
            tmp.next = b;  
            cin >> tmp.len >> tmp.cost;  
            edge[a].push_back(tmp);  
            tmp.next = a;  
            edge[b].push_back(tmp);  
        }  
        cin >> stNode >> enNode;  
        for(i = 1; i <= n; i++) dst[i] = inf; //注意2，別忘記寫此句來初始化dst[]  
        for(i = 0; i < edge[stNode].size(); i++){//注意1，從下標0開始存元素，誤寫成i <= edge[stNode].size()  
            dst[edge[stNode][i].next] = edge[stNode][i].len;  
            //cout << dst[2] << endl;  
            spend[edge[stNode][i].next] = edge[stNode][i].cost;  
        }  
        memset(book, 0, sizeof(book));  
        book[stNode] = 1;  
        //開始迪傑斯特拉演算法，進行剩餘n-1次鬆弛  
        int k;  
        for(k = 1; k <= n-1; k++){  
            //找離源點最近的頂點u  
            int minnode, min = inf;  
            for(i = 1; i <= n; i++){  
                if(book[i] == 0 && min > dst[i] /* || min == dst[i]&& edge[stnode][min].cost > edge[stnode][i].cost*/){  
                    min = dst[i];  
                    minnode = i;  
                }  
            }  
            //cout << setw(2) << minnode;  
            book[minnode] = 1;//易錯點1，錯寫成book[i]=1  
            //以中心點u為轉折點來更新路徑陣列和花費陣列  
            for(i = 0; i < edge[minnode].size(); i++){  
                int t = edge[minnode][i].next;//別忘了加此句，表示與結點minnode相鄰的點  
                if(book[t] == 0 && dst[t] > dst[minnode] + edge[minnode][i].len || dst[t] == dst[minnode] + edge[minnode][i].len && spend[t] > spend[minnode] + edge[minnode][i].cost){  
                    dst[t] = dst[minnode] + edge[minnode][i].len;  
                    spend[t] = spend[minnode] + edge[minnode][i].cost;  
                }  
            }  
        }  
        cout << dst[enNode] << setw(3) << spend[enNode] << endl;  
    }  
    return 0;  
}

程式執行結果如下：


使用鄰接表時，注意更新dst[]，book[]時要使用鄰接表元素對應下標中的next成員，而涉及到權值加減時時需要使用鄰接表中的對應下標來取得權值；而使用鄰接矩陣就沒這麼多顧慮了，因為這時候鄰接矩陣對應下標和dst[]要更新元素的下標正好一致，都是從1開始編號。

4），Bellman-Ford演算法(解決負權邊，解決單源最短路徑，前幾種方法不能求含負權邊的圖)：：時間複雜度O(nm),空間複雜度O(m)
主要思想：對所有的邊進行n-1輪鬆弛操作，因為在一個含有n個頂點的圖中，任意兩點之間的最短路徑最多包含n-1邊。換句話說，第1輪在對所有的邊進行鬆弛後，得到的是從1號頂點只能經過一條邊到達其餘各定點的最短路徑長度。第2輪在對所有的邊進行鬆弛後，得到的是從1號頂點只能經過兩條邊到達其餘各定點的最短路徑長度，......
以下是圖示：


此外，Bellman_Ford還可以檢測一個圖是否含有負權迴路：如果在進行n-1輪鬆弛後仍然存在dst[e[i]] > dst[s[i]]+w[i]。演算法核心程式碼如下：

#define inf 999999999  
for(i = 1; i <= n; i++) dst[i] = inf;  
dst[1] = 0;  
for(k = 1; k <= n-1; k++){  
    for(i = 1; i <= m; i++){  
        if(dst[e[i]] > dst[s[i]] + w[i])  
            dst[e[i]] = dst[s[i]] + w[i];  
    }  
}  
//檢測負權迴路  
flag = 0;  
for(i = 1; i <= m; i++){  
    if(dst[e[i]] > dst[s[i]] + w[i])  
        flag = 1;  
}  
if(flag) cout << "此圖含有負權迴路";

例1：對圖示中含負權的有向圖，輸出從結點1到各結點的最短路徑，並判斷有無負權迴路。

/***先輸入n，m，分別表結點數和邊數，之後輸入m個三元組，各表起點，終點，邊權，輸出1號結點到各結點的最短路徑****/  
#include <iostream>  
#include <iomanip>  
using namespace std;  
#define nmax 1001  
#define inf 99999999  
int n, m, s[nmax], e[nmax], w[nmax], dst[nmax];  
int main(){  
    while(cin >> n >> m && n != 0 && m != 0){  
        int i, j;  
        //初始化三個陣列：起點陣列s[],終點陣列e[],權值陣列w[],最短路徑陣列dst[]  
        for(i = 1; i <= m; i++)  
            cin >> s[i] >> e[i] >> w[i];  
        for(i = 1; i <= n; i++)  
            dst[i] = inf;  
        dst[1] = 0;  
        //使用Bellman_Ford演算法  
        for(j = 1; j <= n-1; j++){  
            for(i = 1; i <= m; i++){  
                if(dst[e[i]] > dst[s[i]] + w[i])  
                    dst[e[i]] = dst[s[i]] + w[i];  
            }  
        }  
        //測試是否有負權迴路並輸出  
        int flag = 0;  
        for(i = 1; i <= m; i++)  
            if(dst[e[i]] > dst[s[i]] + w[i])  
                flag = 1;  
        if(flag) cout << "此圖含有負權迴路\n";  
        else{  
            for(i = 1; i <= n; i++){  
                if(i == 1)  
                    cout << dst[i];  
                else   
                    cout << setw(3) << dst[i];  
            }  
            cout << endl;  
        }  
    }  
    return 0;  
}
程式執行結果如下：


相關推薦

圖論：圖的四種最短路徑演算法

本文總結了圖的幾種最短路徑演算法的實現：深度或廣度優先搜尋演算法，弗洛伊德演算法，迪傑斯特拉演算法，Bellman-Ford演算法1），深度或廣度優先搜尋演算法（解決單源最短路徑）從起始結點開始訪問所有的深度遍歷路徑或廣度優先路徑，則到達終點結點的路徑有多條，取其中路徑權值最

簡單圖論：遍歷所有最短路徑

今天遇到了兩道要求遍歷所有最短路徑的題，我一直做不對的原因竟是我把無向圖當成了有向圖，鬱悶的要死。 解決遍歷所有最短路徑，其實思路很簡單，首先通過經典演算法[各種演算法，Dijkstra,bellman,floyd]求出最短路徑的長度，然後就只能DFS來找尋起始點、終點一樣

資料結構 圖論中求單源最短路徑實現 純程式碼

如下有向圖 求出單源起點A到所有其他節點的最短路徑 完整程式碼： #include <stdio.h> #include <memory.h> //圖論的迪傑斯特拉演算法 #define FINITY 200 #define M 20 //單源點頂點到其他

圖的五種最短路徑演算法

本文總結了圖的幾種最短路徑演算法的實現：深度或廣度優先搜尋演算法，費羅伊德演算法，迪傑斯特拉演算法，Bellman-Ford 演算法。1）深度或廣度優先搜尋演算法（解決單源最短路徑）從起點開始訪問所有深度遍歷路徑或廣度優先路徑，則到達終點節點的路徑有多條，取其中路徑權值最短的

圖的鄰接矩陣表示與最短路徑演算法（ Dijkstra ）程式碼實現

#include <stdio.h> #define MAX_VERTEX_NUM 20 //最大頂點個數 typedef int VRTYPE, InfoType; typedef enum {DG, DN, UDG, UD

圖論四：最短路徑演算法

一、廣度優先搜尋 1、思路：距離開始點最近的點首先被賦值，最遠的點最後被賦值。 2、適用範圍：對於非負數權的無圈圖來說（單源最短路徑）。 3、演算法實現： （1）一個佇列記錄每個每個節點的編號。 （2）將起始節點入隊，將所有節點到起始節點的距離設定為無窮大，起始節點到起始節點的距離為0； （3）取

圖論演算法：最短路徑——無權最短路徑演算法和Dijkstra演算法C++實現

前言        今天將給大家介紹的是圖論演算法中的另外一個基礎部分——最短路徑演算法；其中又分為無權最短路徑，單源最短路徑，具有負邊的最短路徑以及無圈圖等；而這次將介紹常見的兩個——無權最短路徑以及單源最短路徑。接下來就開始我們的講解吧~~原理        最短路徑演算

圖論之Dijkstra最短路徑演算法

圖論中最有名的問題可能就屬最短路徑了。最短路徑問題要求解的是：如果從圖中某一頂點（稱為源點）到達另一頂點（稱為終點）的路徑可能不止一條，如何找到一條路徑，使得沿此路徑各邊上的權值總和（即從源點到終點的距離）達到最小，這條路徑稱為最短路徑（shortestpath）。最短路徑有很多特殊的情況，包括有向圖還是無向

資料結構：圖——圖的遍歷、最小生成樹、最短路徑演算法

前言 在這裡,如果大家對圖或者資料結構還不太熟悉,想找一個動態的生成過程來參考,這是一個不錯的網站. 知識框架 圖的定義 線上性結構中，資料元素之間滿足唯一的線性關係，每個資料元素(除第一個和最後一個外)只有一個直接前趨和一個直接後繼； 在樹形結構中，資料元素之間有著明顯的層次關係，

12.帶權有向圖中任意兩點間的最短路徑

其實它的程式碼理解起來真的挺難的我覺得！！！ 昨天看了一下午感覺晦澀難懂，還是matlab好用，直接呼叫函式就可以了！！！ 不過這裡還是得跟大家介紹一下： 1.問題的理解： 像這種帶權的有向圖，每一行都表示該行標號對應列標號的有向權值，本身到本身的數值為0，沒辦法

有向圖的無權圖最短路徑演算法與帶權圖的Dijkstra演算法

  最短路徑演算法是圖論中的常見問題，在實際中有著較為廣泛的應用，比如查詢從一個地方到另一個地方的最快方式。問題可以概括為，對於某個輸入頂點s，給出s到所有其它頂點的最短路徑。水平有限，暫時先對這個問題的求解做簡單記錄。   無權圖是有權最短路徑的特例，即邊的權重均是1。演

圖的最短路徑演算法——Dijkstra演算法的 java 實現

首先，定義Graph類，主要用於儲存圖的鄰接矩陣，實際上儲存的是每個節點的出邊（outgoing arcs）集合。 Graph 類繼承自 SparseMatrix 類，因為大多數圖（網路）都是稀疏的，所以用稀疏矩陣來儲存圖的邊及每條邊的權值非常方便。 packa

圖相關（二）圖的鄰接矩陣表示（C++）及最短路徑演算法

一.Dijikstra演算法 注意：計算最短路徑時，需要把鄰接矩陣中沒有邊的位置初始化為無窮大；此處以INF表示，INF可以取0x3f3f3f3f，不能直接設為INT_MAX（因為做加法時會上溢）。 測試用圖： 其鄰接矩陣表示為： vector<vector<int

拓撲排序+最短路徑（無環加權有向圖最短路徑演算法）

特點：        1、線性時間內解決單點最短路徑問題        2、能夠處理負權邊問題        3、能夠找出最長路徑 不足：因為是基於拓撲排序的，所以不能解決帶環的問題  import java.util.ArrayList; import java.util

圖的最短路徑演算法(Dijkstra，Floyd)的實現

從某個源點到其餘各頂點的最短路徑 迪杰特斯拉演算法 Dijkstra(迪傑斯特拉)演算法是典型的單源最短路徑演算法，用於計算一個節點到其他所有節點的最短路徑。主要特點是以起始點為中心向外層層擴充套件，直到擴充套件到終點為止。 演算法步驟如下：

有向圖的最短路徑演算法

最短路徑演算法屬於資料結構的圖的應用知識。先介紹基本的圖的概念。 圖由頂點集和邊集組成。（一張圖裡不就是有頂點和邊）。圖中邊帶有方向就是有向圖，否則就是無向圖。圖的儲存結構分為鄰接表和鄰接矩陣。（鄰接表主要採用順序儲存和鏈式儲存結合的方式）。採用連結表這種都是對於稀疏圖而言

資料結構——帶權有向圖（最短路徑演算法Dijkstra演算法）

Dijkstra演算法是由荷蘭電腦科學家艾茲格·迪科斯徹發現的。演算法解決的是有向圖中最短路徑問題。 舉例來說，如果圖中的頂點表示城市，而邊上的權重表示著城市間開車行經的距離。 Dijkstra演算法可以用來找到兩個城市之間的最短路徑。 Dijkstra演算法的輸入包含了一個有權重的有向圖G，以及G中的一個

求圖中最短路徑演算法之Dijkstra演算法——C++實現並優化

Dijkstra演算法是一種比較經典的求圖中最短路徑演算法，它是一種貪心演算法，可以求出從源節點到圖中其他所有節點的最短路徑。適用範圍：用於求有向或無向加權圖中兩點間的最短路徑，其中邊的權值不能為負。 最近重新學習了該演算法，並用C++將其實現，同時對程式碼進行了優化，優化

計算無向無權圖中兩點間所有的最短路徑

  一、例子 如上圖，節點0到節點5的最短路徑長度為3，有兩條最短路徑： 路徑1：0 — 1 — 4— 5 路徑2：0 — 1 — 2— 5 二、相關名稱 tempLadder：             儲存當前正在計算的路徑 canditStack：          

有向加權圖的最短路徑演算法-Dijkstra

1 有向加權圖的資料結構如下 4 5 0.35 5 4 0.35 4 7 0.37 5 7 0.28 7 5 0.28 5 1 0.32 0 4 0.38 0 2 0.26 7 3 0.39 1 3 0.29 2 7 0.34 6 2 0.40 3 6 0.52 6 0 0