圖論中一個經典問題就是求最短路，最為基礎和最為經典的演算法莫過於 Dijkstra 和 Floyd 演算法，一個是貪心演算法，一個是動態規劃，這也是演算法中的兩大經典代表。用一個簡單圖在紙上一步一步演算, 帶回溯的筆記在這篇。

對於平時的練習，一個很厲害的 ACMer 說：“刷水題可以加快我們程式設計的速度，做經典則可以讓我們觸類旁通，初期如果遇見很多編不出，不妨就寫虛擬碼，理思路，在紙上進行整體分析和一步步的演算，然後在轉換成程式碼，再反覆迭代”。Linus 不是也說了 "Nobody actually creates perfect code the first time around, except me. But there’s only one of me."  ^_^  對於演算法的學習，絕大多數都是把問題分解變形，然後套用以前或別人的思路。只有把經典的演算法都爛熟於心時，解決問題時才可以做到不知不覺的套用已有的思路和經驗。

單源最短路

• 貪心演算法：每次找最近的點，區域性最優等於全域性最優，數學歸納法可證
• 維護起點 start 到每個點的距離
• 時間複雜度 O(n^2)
• 附加空間複雜度 O(n)

Dijkstra 演算法虛擬碼：
Q = {}                                       // 已求出到 start 點最短路的點集合，初始為空
d[s] = 0, 其餘值為正無窮大
while (|Q| < |V|)                            // 數學符號|A|表示集合A的點數
    取出不在Q中的最小的d[i]
    for (i相鄰的點j，j不屬於Q)
        d[j] = min(d[j], d[i] + c[i][j])     //維護距離
    Q = Q + {i}

全域性最短路

• 動態規劃：每次加入一個點
• 維護任意兩點間的距離
• 時間複雜度 O（n^3）
• 附加空間複雜度 O（n^2）

Floyd 演算法虛擬碼:        # 直接改成 Python 了，沒辦法就是喜歡 Python :)
for k in range(0, n):			
    for i in range(0, n):
        for j in range(0, n):            
            g[i][j] = min(g[i][j], g[i][k]+g[k][j])

小實驗

一個圖如下所示：

原始碼 ( C 實現）

#include <stdio.h>
#define N 65536

/* 計算有 9 個點的圖的單源最短路  */
void Dijkstra(int graph[9][9],  int start, int path[9]){
	int num=9, min, vertex, i, j;
	int flag[num];
	for(i = 0; i < num; ++i){ 	//初始化所有點都未計算，第一次距離直接讀鄰接矩陣
		path[i] = graph[start][i];
		flag[i] = 0;
	}

	for(i = 0; i < num; ++i){
		min = N;
		for(j = 0; j < num; ++j){
			if(flag[j] == 0 && min > path[j]){	//求未計算過的點中距離 start 最近點
				min = path[j];
				vertex = j;
			}
		}
		flag[vertex] = 1; 	//將上面計算的點標記為計算過
		for(j = 0; j < num; ++j){	//維護所有未計算過點的距離
			if(flag[j] == 0 && path[j] > path[vertex] + graph[vertex][j]){
				path[j] = path[vertex] + graph[vertex][j];
			}
		}
	}
}

/* 計算一個 9 個點的圖所有點到所有點間的最短路 */
void Floyd(int graph[9][9]){
	int num = 9, i, j, k;
	for(k = 0; k < num; ++k){			//中轉點
		for(i = 0; i < num; ++i){		//出發點
			for(j = 0; j < num; ++j){	//到達點
				if(graph[i][j] > graph[i][k] + graph[k][j]){
					graph[i][j] = graph[i][k] + graph[k][j];
				}
			}
		}
	}
}

int main() {
	int graph[9][9]={
			{0, 1, 5, N, N, N, N, N, N},
			{1, 0, 3, 7, 5, N, N, N, N},
			{5, 3, 0, N, 1, 7, N, N, N},
			{N, 7, N, 0, 2, N, 3, N, N},
			{N, 5, 1, 2, 0, 3, 6, 9, N},
			{N, N, 7, N, 3, 0, N, 5, N},
			{N, N, N, 3, 6, N, 0, 2, 7},
			{N, N, N, N, 9, 5, 2, 0, 4},
			{N, N, N, N, N, N, 7, 4, 0}
	};
	int start=0, path[9], i, j;
	Dijkstra(graph, start, path);	//計算結果寫入 path 陣列
	printf("點 %d 到所有點的最短距離：\n", start);
	for(i=0; i<9; ++i){
		printf("%d ",path[i]);
	}

	Floyd(graph); 	//計算後的結果也直接寫入graph
	printf("\n所有點到所有點的最短距離\n");
	for(i=0; i<9; ++i){
		for(j=0; j<9; ++j){
			printf("%d ",graph[i][j]);
		}
		printf("\n");
	}

	return 0;
}

/****** 執行結果 ***********
點 0 到所有點的最短距離：
0 1 4 7 5 8 10 12 16
所有點到所有點的最短距離
0 1 4 7 5 8 10 12 16
1 0 3 6 4 7 9 11 15
4 3 0 3 1 4 6 8 12
7 6 3 0 2 5 3 5 9
5 4 1 2 0 3 5 7 11
8 7 4 5 3 0 7 5 9
10 9 6 3 5 7 0 2 6
12 11 8 5 7 5 2 0 4
16 15 12 9 11 9 6 4 0
*****************************/