Dijkstra算法只能求取邊的權重爲非負的圖的最短路徑,而Bellman-Ford算法能夠求取邊的權重爲負的圖的最短路徑(但Bellman-Ford算法在圖中存在負環的狀況下,最短路徑是不存在的(負無窮))。html
Dijkstra算法本質上是一種貪心算法,1959年,Edsger Dijkstra提出了該算法用於解決單源最短路徑問題,即在給定每條邊的長度\(\mathcal{l}\),求取源節點s到其它全部節點的最短路徑。Dijkstra算法維護一個節點集合S,S中的節點到源點的最短距離d已經肯定了,即「Explored」。c++
初始化時,\(S={s},d(s)=0\),接下來開始循環,對於每個節點\(v\in V-S\),選出到集合S的距離最近的節點\(v^*\),即最小化下面這個問題:
\begin{equation}
d'(v)=\min_{e=(u,v):u\in S}d(u)+\mathcal{l}_e
\end{equation}
咱們將\(v^*\)加入到集合S,並定義\(d(v^*)=d'(v^*)\)。而後繼續下一次循環。算法
算法僞代碼以下:
api
每次while循環,將1個節點加入集合S中,因此共n-1次外層循環。對於一個有m條邊的圖而言,求解式(1)最壞狀況下,須要遍歷全部的邊,即須要\(\mathcal{O}(m)\)的時間複雜度,因此程序總體的時間複雜度爲\(\mathcal{O}(mn)\)。若是看下文例題中POJ2387的樸素實現,可能會發現算法複雜度是\(\mathcal{O}(n^2)\),不是\(\mathcal{O}(mn)\)。但其實在例題中,在輸入時,每兩個節點間只有一條邊相連(若是有多條,則只保留最短的一條),另外,每次將節點v_opt新加入S中時,咱們會更新v_opt節點相鄰的節點的\(d'(v)\)的值,並將其存儲在數組中。從而每次求解式(1)時,咱們只須要遍歷非S集合的節點的\(d'(v)\)值,就能獲得式(1)的答案,從而下降了求解式(1)的複雜度(降爲\(\mathcal{O}(n)\)),總體複雜度降爲\(\mathcal{O}(n^2)\),而對於通常狀況,理論上的複雜度就是\(\mathcal{O}(mn)\)。數組
上文中提到將非S集合的節點的\(d'(v)\)值存儲在數組裏,每次遍歷數組獲得式(1)的答案(即\(d'(v)\)的最小值),而這一個地方還能夠進一步優化,採起優先隊列存儲非S集合的節點,節點對應的\(d'(v)\)做爲鍵值,若採用二叉堆實現優先隊列(能夠參考優先隊列及(二叉)堆),每次只須要\(\mathcal{O}(\log n)\)的時間便可求得\(d'(v)\)的最小值(獲得最小值後需刪除該值)。函數
優先隊列實現的僞代碼以下:
優化
典型Dijkstra模板題,須要注意不一樣landmark(節點)間的路徑可能有多條,這是一個WA點,若用鄰接矩陣存儲圖,解決辦法是隻保留最短的一條路徑。若用鄰接表存儲圖,則不須要對重複邊進行特別處理。spa
用explored數組來標記是否屬於集合S,外層for循環共執行n次,每次標記一個節點,循環內遍歷非S集合的節點,求出到S集合的距離最短的節點v_opt,而後更新與v_opt相鄰的節點\(d'(v)\)(即distance數組)的值。總體複雜度\(\mathcal{O}(n^2)\)設計
Result: 4280kB, 125ms. 提及來POJ的Time不是很固定啊,一樣的代碼,上次是63ms,此次是125ms。code
#include <stdio.h> #include <string.h> #include <limits.h> #include <queue> int t, n; int adjacency_matrix[1005][1005]; int distance[1005]; int explored[1005];//標記是否屬於集合S void DijkstraSimple() { distance[n] = 0; for (int i = 1; i <= n; i++) {//每次將一個節點加入S,共循環n次 int min = 0x3f3f3f3f; int v_opt;//最小化式(1)的節點 for (int v = 1; v <= n; v++)//找出S集合中最小化式(1)的節點 if (!explored[v] && distance[v] < min) { min = distance[v]; v_opt = v; } explored[v_opt] = 1; for (int v = 1; v <= n; v++) if (!explored[v])//v未添加進集合S且v_opt、v之間有邊相連 distance[v] = std::min(distance[v], distance[v_opt] + adjacency_matrix[v_opt][v]); } } int main() { while (scanf("%d %d", &t, &n) != EOF) { memset(adjacency_matrix, 0x3f, sizeof(adjacency_matrix)); memset(distance, 0x3f, sizeof(distance)); memset(explored, 0, sizeof(explored)); int u, v, length; for (int i = 1; i <= t; i++) { scanf("%d %d %d", &u, &v, &length); if (adjacency_matrix[u][v] > length) {//兩個landmark之間可能有多條路,這是一個WA點,有多條路時,取length最小的路 adjacency_matrix[u][v] = length; adjacency_matrix[v][u] = length; } } DijkstraSimple(); printf("%d\n", distance[1]); } return 0; }
圖2優先隊列實現的僞代碼中,要求經過decrease_key函數改變特定節點\(v\)的鍵值,但實際上,正如個人優先隊列及(二叉)堆這篇博客中提到的,優先隊列的基本操做並不包含改變特定節點的鍵值。在優先隊列及(二叉)堆庫函數實現小節中,我也提到能夠經過維護一個position數組來實現改變特定節點的鍵值。下列代碼正是基於這種思路實現改變特定節點的鍵值。
Result: 388kB, 16ms; 388kB, 32ms. POJ的Time確實不太穩定,一樣的代碼,隔十分鐘提交的結果就不太同樣。可是相對樸素實現速度提升不少。
/* 本身實現的堆算法,經過position記錄下元素在堆(數組)中的位置,能夠直接更改特定編號的元素的鍵值 */ #include <stdio.h> #include <math.h> #include <string.h> #include <algorithm> //上限 #define N (1000 + 10) #define M (4000 + 10)//無向圖,應大於邊數量的2倍 #define parent(i) (int)floor(i/2) #define left(i) i * 2 #define right(i) i * 2 + 1 struct element { int number;//元素編號 int key;//元素鍵值 element() {} element(int number, int key) : number(number), key(key) {} }; element A[N];//存儲最小堆 int position[N];//存儲元素在堆(數組)中的位置 int min_heap_size; int explored[N];//標記是否屬於集合S int distance[N];//距源點的最短距離 int t, n; struct edge {//經過鏈表存儲邊 int v, length, next; }; edge e[M]; int head[N];//節點的第一條邊在e數組中位置 int num_of_edges; int add_edge(int u, int v, int length1, int length2) { int& i = num_of_edges; e[i].v = v; e[i].length = length1; e[i].next = head[u]; head[u] = i++; e[i].v = u; e[i].length = length2; e[i].next = head[v]; head[v] = i++; return i; } template<class T> void exchange(element* array, int i, int j) { position[A[i].number] = j;//交換二者的位置 position[A[j].number] = i; T temp = array[i];//交換兩者的數據 array[i] = array[j]; array[j] = temp; } //最小堆 void heap_decrease_key(int i, int key) { if (key > A[i].key) printf("error: new key is bigger than current key."); A[i].key = key; while (i > 1 && A[parent(i)].key > A[i].key) { exchange<element>(A, i, parent(i)); i = parent(i); } } void min_heap_insert(element elem) { min_heap_size++; A[min_heap_size].number = elem.number; A[min_heap_size].key = 0x3f3f3f3f; position[elem.number] = min_heap_size;//記錄下位置 heap_decrease_key(min_heap_size, elem.key); } element heap_minimum() { return A[1]; } void min_heapify(int i) { int l = left(i), r = right(i); int smallest = i; if (l <= min_heap_size && A[l].key < A[i].key) smallest = l; if (r <= min_heap_size && A[r].key < A[smallest].key) smallest = r; if (smallest != i) { exchange<element>(A, i, smallest); min_heapify(smallest); } } element heap_extract_min(void) { element min = A[1]; position[A[min_heap_size].number] = 1;//heap_size位置的挪到1的位置 A[1] = A[min_heap_size]; min_heap_size--; min_heapify(1); return min; } void DijkstraPriorityQueue() { min_heap_insert(element(n, 0)); distance[n] = 0; for (int i = 1; i < n; i++)//將全部節點都放入優先隊列中 min_heap_insert(element(i, 0x3f3f3f3f)); for (int i = 1; i <= n; i++) {//每次把一個節點從優先隊列中取出加入到S中,外層循環n次 element front_elem = heap_extract_min(); int u = front_elem.number; explored[u] = 1; distance[u] = front_elem.key; for (int j = head[u]; j >= 0; j = e[j].next) {//遍歷u出發的全部邊 int v = e[j].v; if (explored[v]) continue; if (A[position[v]].key > distance[u] + e[j].length) heap_decrease_key(position[v], distance[u] + e[j].length); } } } void Init() { min_heap_size = 0; memset(position, -1, sizeof(position)); memset(explored, 0, sizeof(explored)); memset(distance, 0x3f, sizeof(distance)); num_of_edges = 0; memset(head, -1, sizeof(head)); } int main() { while (scanf("%d %d", &t, &n) != EOF){ Init(); int u, v, length; for (int i = 1; i <= t; i++) { scanf("%d %d %d", &u, &v, &length); add_edge(u, v, length, length); } DijkstraPriorityQueue(); printf("%d\n", distance[1]); } return 0; }