最短路徑
問題背景：地圖上有很多個城市，已知各城市之間距離（或者是所需時間，后面都用距離了），一般問題無外乎就是以下幾個：
- 從某城市到其余所有城市的最短距離【單源最短路徑】
- 所有城市之間相互的最短距離【任意兩點最短路徑】
- 各城市距離一致，給出需要最少中轉方案 【最少中轉】
深度優先搜索
適用范圍：啥都不適用，只能處理n<10的情況
深搜求最短路徑的思想和用深搜迷宮尋路有一點像，找出所有的從起點到目標點的路徑，選出其中最短的一條。
此算法僅供娛樂參考，實際不會用它的，因為算法復雜度是$O(n!)$
深度優先搜索：
const int inf = 1 << 30; int M[50][50]; bool fuck[50]; int n, res; //cur-當前所在城市編號，dis-當前已走過的路徑 void dfs(int cur, int dis) { //若當前的路徑值已比之前找到的最短路大，沒必要繼續往下搜索了，其實沒什么必要，深搜本來就屬於暴力算法，這個小優化屬於杯水車薪 if (dis > res) return; //當前已到達目的城市，更新min if (cur == n) { res = min(res, dis); return; } //對1~n號城市依次嘗試 for (int i = 1; i <= n; i++) { //若cur與i之間有路，且i沒有在已走過的路徑中 if (M[cur][i] != inf && !fuck[i]) { fuck[i] = true; //標記i為已走的路徑 dfs(i, dis + M[cur][i]); //繼續搜索 fuck[i] = false; //回溯 } } }
#include <iostream> #include <algorithm> #include <fstream> #include <cstdio> #include <queue> using namespace std; const int inf = 1 << 30; int M[50][50]; int path[50]; bool fuck[1000]; int n, m, res = inf, cnt; //cur-當前所在城市編號，dis-當前已走過的路徑 void dfs(int cur, int dis,int destination,int k) { //若當前的路徑值已比之前找到的最短路大，沒必要繼續往下搜索了，其實沒什么必要，深搜本來就屬於暴力算法，這個小優化屬於杯水車薪 //if (dis > res) // return; //當前已到達目的城市，更新min if (cur == destination) { res = min(res, dis); //cnt++; for (int i = 0; i < k; i++) { cout << path[i] << ' '; } cout << endl; return; } //對1~n號城市依次嘗試 for (int i = 1; i <= n; i++) { //若cur與i之間有路，且i沒有在已走過的路徑中 if (M[cur][i] != 0 && M[cur][i] != inf && !fuck[i]) { fuck[i] = true; //標記i為已走的路徑 path[k] = i; dfs(i, dis + M[cur][i], destination, k + 1); //繼續搜索 fuck[i] = false; //回溯 } } } int main() { #ifdef LOCAL fstream cin("data.in"); #endif // LOCAL cin >> n >> m; for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { if (i != j) M[i][j] = inf; } } for (int i = 0; i < m; i++) { int c1, c2, c3; cin >> c1 >> c2 >> c3; M[c1][c2] = c3; M[c2][c1] = c3; } cnt = 0; res = inf; fuck[1] = true; path[0] = 1; dfs(1, 0, 4, 1); return 0; }
寬度優先搜索
適用范圍：最少中轉方案，處理n的級別看臉
假如現在是最少中轉方案問題（或者所有邊的權值一致） ，問從城市1到城市4需要經過的最少中轉城市個數。
這類問題和寬搜求迷宮的最短路徑思想完全一樣，從開始點逐層擴展，找到目標停止。
寬搜的算法復雜度也是$O(n!)$，不過看臉，如果在前面幾層就找到目標了，就比較快。
也就是目標點需要中轉幾次，如果一次都不要中轉，那么第二層就能搜索到；如果需要中轉n-2次，那就得搜索到最后一層，就也是$O(n!)$了
寬度優先搜索：
int M[50][50]; int path[50]; bool fuck[1000]; int n, m, res = inf, cnt; int bfs(int start, int destination){ queue<pair<int, int>> q; //城市編號、當前是第幾座城市 q.push({ start,0 }); //把起始點加入隊列 fuck[start] = true; //標記為已在路徑中 while (!q.empty()){ int cur = q.front().first, dis = q.front().second; q.pop(); for (int i = 1; i <= n; i++) { //如果當前點到i點有路，並且當前還沒有加入隊列中 if (M[cur][i] != inf && !fuck[i]) { q.push({ i,dis + 1 }); fuck[i] = true; if (i == destination) //如果發現了目標點 return dis;//這里具體是算多少步看題目咋問了 } } } }
#include <iostream> #include <algorithm> #include <fstream> #include <cstdio> #include <queue> using namespace std; const int inf = 1 << 30; int M[50][50]; int path[50]; bool fuck[1000]; int n, m, res = inf, cnt; int bfs(int start, int destination){ queue<pair<int, int>> q; //城市編號、當前是第幾座城市 q.push({ start,0 }); //把起始點加入隊列 fuck[start] = true; //標記為已在路徑中 while (!q.empty()){ int cur = q.front().first, dis = q.front().second; q.pop(); for (int i = 1; i <= n; i++) { //如果當前點到i點有路，並且當前還沒有加入隊列中 if (M[cur][i] != inf&& !fuck[i]) { q.push({ i,dis + 1 }); fuck[i] = true; if (i == destination) //如果發現了目標點 return dis;//這里具體是算多少步看題目咋問了 } } } } int main() { #ifdef LOCAL fstream cin("data.in"); #endif // LOCAL cin >> n >> m; for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { if (i != j) M[i][j] = inf; } } for (int i = 0; i < m; i++) { int c1, c2, c3; cin >> c1 >> c2 >> c3; M[c1][c2] = c3; M[c2][c1] = c3; } cout << bfs(1, 4); return 0; }
這兩個算法我覺得算是迷宮尋路算法的延伸，可以看下迷宮尋路問題全解，用在求最短路徑中的話，效率太低，無法解決實際問題。
接下來才是重點。
迪傑斯特拉（Dijkstra）算法
適用范圍：不含負權邊的單源最短路徑、最少中轉
不含負權邊就是所有路徑長度大於0，牽扯到負權邊，請參考 Bellman-Ford算法
思路圖解
維護一個$dis$數組記錄起點（按題目要求來，這里取$1$） 到達的所有節點的距離。（規定到自己的路徑長度0，到不了的點是 inf（極大值））
找出當前距離$1$最近的結點：$4$。（已經訪問過的，我們標記為紅色，不再次訪問）
借助$4$節點，對$dis$數組進行更新（就是如果結點$1$借助結點$4$到別的結點有更短的路徑，就對$dis$數組進行值替換）
找出當前距離$1$最近的結點：$2$。
走到$2$，無法更新$dis$數組，無操作。
找出當前距離$1$最近的結點：$3$。
借助$3$節點，對$dis$數組進行更新，最后走到$5$節點，退出。（實際過程中，走到最后一個節點，別的節點都訪問過，進行標記了，什么也不會做）。
這個時候$dis$數組就是從起點$1$到所有節點的最短路徑了，如果還有$inf$表示不是連通圖。
簡單版（鄰接矩陣+優先級隊列）：
測試題目：http://acm.hdu.edu.cn/showproblem.php?pid=2544 （數據很弱，建議再做后面一題）
#include <fstream> #include <iostream> #include <queue> #include <algorithm> #include <string.h> using namespace std; const int inf = 1 << 30; int n, m; bool book[1001]; int M[1001][1001]; int dis[1001]; class P { public: int to, dis; P(int t, int d) :to(t), dis(d) {} bool operator< (P a) const { return a.dis < dis; } }; priority_queue<P>q; void initialize() { fill(book, book + n + 1, false); fill(dis, dis + n + 1, inf); for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { if (i != j)M[i][j] = inf; } } } void dijkstra() { dis[1] = 0; q.push({ 1, 0 }); while (!q.empty()) { int v = q.top().to; q.pop(); if (book[v])continue; book[v] = true; for (int i = 1; i <= n; i++) { if (!book[i] && dis[i] > dis[v] + M[v][i]) { dis[i] = dis[v] + M[v][i]; q.push({ i, dis[i] }); } } } } int main() { #ifdef LOCAL fstream cin("data.in"); #endif // LOCAL while (cin >> n >> m) { if (n == 0 && m == 0)break; initialize(); for (int i = 0; i < m; i++) { int A, B, C; cin >> A >> B >> C; M[A][B] = C; M[B][A] = C; } dijkstra(); cout << dis[n] << endl; } return 0; }
正式版（鄰接表+優先級隊列）
測試題目：https://www.luogu.org/problemnew/show/P4779
#include <fstream> #include <iostream> #include <stdio.h> #include <queue> using namespace std; int dis[100001]; bool fuck[100001]; const int inf = 1 << 30; int n, m, s; struct ENode { int to, dis; ENode* next = NULL; ENode() {} ENode(int t, int d) :to(t), dis(d) {} void push(int t, int d) { ENode* p = new ENode(t, d); p->next = next; next = p; } bool operator<(ENode e)const { return e.dis < dis; } }head[100005]; void dijkstra() { priority_queue<ENode>q; fill(dis, dis + n + 1, inf); dis[s] = 0; q.push(ENode(s, 0)); while (!q.empty()) { //獲得當期距離 源點 最近的點 int v = q.top().to, d = q.top().dis; q.pop(); if (fuck[v])continue; fuck[v] = true; ENode* p = head[v].next; while (p) { int to = p->to; if (!fuck[to] && dis[to] > d + p->dis) { dis[to] = d + p->dis; q.push(ENode(to, dis[to])); } p = p->next; } } } int main() { #ifdef LOCAL fstream cin("data.in"); #endif // LOCAL int c1, c2, c3; cin >> n >> m >> s; for (int i = 0; i < m; i++) { //cin >> c1 >> c2 >> c3; scanf("%d%d%d", &c1, &c2, &c3); head[c1].push(c2, c3); } dijkstra(); for (int i = 1; i <= n; i++) { printf("%d ", dis[i]); } cout << endl; return 0; }
提一句如果是要求找最少中轉方案，那么就把每個邊的權值都設為1，在求最短路徑即可。
時間復雜度分析
一般默認迪傑斯特拉算法復雜度為$O(n^2)$，也就是每次從$dis$中獲取路徑最短的結點，需要花費線性的時間$O(n)$，但這是普通情況下。【$n$為頂點數】使用優先級隊列后，從$dis$中獲取路徑最短的結點只需要$O(logn)$（因為我們用了一個標記數組，所以堆中的數據個數不可能會超過$n$，所以是$O(logn)$，如果沒有加這個復雜度是$O(logm)$，m為邊的個數）。所以，堆優化的迪傑斯特拉算法時間復雜度為$O((m+n)logn)$。
關於負權邊
$Dijkstra$是一種基於貪心策略的算法。每次新擴展一個路徑最短的點，更新與它相鄰的所有點。當所有邊權為正時，由於不會存在一個路程更短的沒擴展過的點，所以這個點的路程就確定下來了，這保證了算法的正確性。但也正因為這樣，這個算法不能處理負權邊，因為擴展到負權邊的時候，某個點會產生更短的路徑，但可能該點已被標記。
比如這張圖，按照Dijkstra算法，假如起點是A，一定會先找到C，並且認為已經找到A到C最短路徑，在沒有負邊的時候是這樣的，但現在B到C是-2，這就出現錯誤了。
Floyd算法
Floyd算法屬於動態規划，實現容易，好理解，但缺點就是時間復雜度高是$O(n^3)$。
$M [ j ] [ k ]$ 表示從$ j$ 到 $k$ 的路徑，而 $i$ 表示當前 $j$ 到 $k$ 可以借助的點；紅色部分表示，如果 $j$ 到 $i$ ，$i$ 到 $k$ 是通的，就將 $j$ 到 $k$ 的值更新為$min(M[j][i] + M[i][k],M[j][k] )$
for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { for (int k = 1; k <= n; k++) { if (j != k && M[j][i] != inf && M[i][k] != inf) M[j][k] = min(M[j][i] + M[i][k], M[j][k]); } } }
給個題目鏈接，可以交試一下：http://www.dotcpp.com/oj/problem1709.html
#include <iostream> #include <queue> using namespace std; #define inf 2147483647 int M[1000][1000]; int main() { int n; queue<int>q; cin >> n; for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { cin >> M[i][j]; if (M[i][j] == 0 && i != j)M[i][j] = inf; } } for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { for (int k = 1; k <= n; k++) { if (M[j][k] != 0) { if (M[j][i] != inf && M[i][k] != inf) { M[j][k] = M[j][i] + M[i][k] < M[j][k] ? M[j][i] + M[i][k] : M[j][k]; } } } } } for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { if (M[i][j] == inf)cout << -1 << " "; else cout << M[i][j] << " "; } cout << endl; } return 0; }
Dijkstra & Floyd 對比
$Dijkstra$算法的復雜度為$O(n^2)$【不考慮堆優化的情況】，如果采用Dijkstra算法來計算圖中任兩點之間的最短距離，復雜度也為$O(n^3)$，雖然復雜度相同，但是看代碼，兩個算法運算量差了很多，也就是$Dijkstra$算法輸在了常數項。但是堆優化后的$Dijkstra$算法，還是要完全優於$Floyd$算法的。
對比：
