基本思想
通過Dijkstra計算圖G中的最短路徑時，需要指定起點s(即從頂點s開始計算)。
此外，引進兩個集合S和U。S的作用是記錄已求出最短路徑的頂點(以及相應的最短路徑長度)，而U則是記錄還未求出最短路徑的頂點(以及該頂點到起點s的距離)。
初始時，S中只有起點s；U中是除s之外的頂點，並且U中頂點的路徑是"起點s到該頂點的路徑"。然後，從U中找出路徑最短的頂點，並將其加入到S中；接着，更新U中的頂點和頂點對應的路徑。 然後，再從U中找出路徑最短的頂點，並將其加入到S中；接着，更新U中的頂點和頂點對應的路徑。 ... 重複該操作，直到遍歷完所有頂點。
具體過程
初始狀態：S是已計算出最短路徑的頂點集合，U是未計算除最短路徑的頂點的集合！
第1步：將頂點D加入到S中。
此時，S={D(0)}, U={A(∞),B(∞),C(3),E(4),F(∞),G(∞)}。 注:C(3)表示C到起點D的距離是3。
第2步：將頂點C加入到S中。
上一步操作之後，U中頂點C到起點D的距離最短；因此，將C加入到S中，同時更新U中頂點的距離。以頂點F爲例，之前F到D的距離爲∞；但是將C加入到S之後，F到D的距離爲9=(F,C)+(C,D)。
此時，S={D(0),C(3)}, U={A(∞),B(23),E(4),F(9),G(∞)}。
第3步：將頂點E加入到S中。
上一步操作之後，U中頂點E到起點D的距離最短；因此，將E加入到S中，同時更新U中頂點的距離。還是以頂點F爲例，之前F到D的距離爲9；但是將E加入到S之後，F到D的距離爲6=(F,E)+(E,D)。
此時，S={D(0),C(3),E(4)}, U={A(∞),B(23),F(6),G(12)}。
第4步：將頂點F加入到S中。
此時，S={D(0),C(3),E(4),F(6)}, U={A(22),B(13),G(12)}。
第5步：將頂點G加入到S中。
此時，S={D(0),C(3),E(4),F(6),G(12)}, U={A(22),B(13)}。
第6步：將頂點B加入到S中。
此時，S={D(0),C(3),E(4),F(6),G(12),B(13)}, U={A(22)}。
第7步：將頂點A加入到S中。
此時，S={D(0),C(3),E(4),F(6),G(12),B(13),A(22)}。
此時，起點D到各個頂點的最短距離就計算出來了：A(22) B(13) C(3) D(0) E(4) F(6) G(12)。
代碼：
package com.smart.reflect;
import java.io.IOException;
import java.util.Scanner;
public class MatrixUDG {
private int mEdgNum; // 邊的數量
private char[] mVexs; // 頂點集合
private int[][] mMatrix; // 鄰接矩陣
private static final int INF = Integer.MAX_VALUE; // 最大值
/*
* 創建圖(自己輸入數據)
*/
public MatrixUDG() {
// 輸入"頂點數"和"邊數"
System.out.printf("input vertex number: ");
int vlen = readInt();
System.out.printf("input edge number: ");
int elen = readInt();
if (vlen < 1 || elen < 1 || (elen > (vlen * (vlen - 1)))) {
System.out.printf("input error: invalid parameters!\n");
return;
}
// 初始化"頂點"
mVexs = new char[vlen];
for (int i = 0; i < mVexs.length; i++) {
System.out.printf("vertex(%d): ", i);
mVexs[i] = readChar();
}
// 1. 初始化"邊"的權值
mEdgNum = elen;
mMatrix = new int[vlen][vlen];
for (int i = 0; i < vlen; i++) {
for (int j = 0; j < vlen; j++) {
if (i == j)
mMatrix[i][j] = 0;
else
mMatrix[i][j] = INF;
}
}
// 2. 初始化"邊"的權值: 根據用戶的輸入進行初始化
for (int i = 0; i < elen; i++) {
// 讀取邊的起始頂點,結束頂點,權值
System.out.printf("edge(%d):", i);
char c1 = readChar(); // 讀取"起始頂點"
char c2 = readChar(); // 讀取"結束頂點"
int weight = readInt(); // 讀取"權值"
int p1 = getPosition(c1);
int p2 = getPosition(c2);
if (p1 == -1 || p2 == -1) {
System.out.printf("input error: invalid edge!\n");
return;
}
mMatrix[p1][p2] = weight;
mMatrix[p2][p1] = weight;
}
}
/*
* 創建圖(用已提供的矩陣)
*
* 參數說明：
* vexs -- 頂點數組
* matrix-- 矩陣(數據)
*/
public MatrixUDG(char[] vexs, int[][] matrix) {
// 初始化"頂點數"和"邊數"
int vlen = vexs.length;
// 初始化"頂點"
mVexs = new char[vlen];
for (int i = 0; i < mVexs.length; i++)
mVexs[i] = vexs[i];
// 初始化"邊"
mMatrix = new int[vlen][vlen];
for (int i = 0; i < vlen; i++)
for (int j = 0; j < vlen; j++)
mMatrix[i][j] = matrix[i][j];
// 統計"邊"
mEdgNum = 0;
for (int i = 0; i < vlen; i++)
for (int j = i + 1; j < vlen; j++)
if (mMatrix[i][j] != INF)
mEdgNum++;
}
/*
* 返回ch位置
*/
private int getPosition(char ch) {
for (int i = 0; i < mVexs.length; i++)
if (mVexs[i] == ch)
return i;
return -1;
}
/*
* 讀取一個輸入字符
*/
private char readChar() {
char ch = '0';
do {
try {
ch = (char) System.in.read();
} catch (IOException e) {
e.printStackTrace();
}
} while (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')));
return ch;
}
/*
* 讀取一個輸入整數
*/
private int readInt() {
Scanner scanner = new Scanner(System.in);
return scanner.nextInt();
}
/*
* 打印矩陣隊列圖
*/
public void print() {
System.out.printf("Martix Graph:\n");
for (int i = 0; i < mVexs.length; i++) {
for (int j = 0; j < mVexs.length; j++)
System.out.printf("%10d ", mMatrix[i][j]);
System.out.printf("\n");
}
}
/*
* Dijkstra最短路徑。
* 即統計圖中"頂點vs"到其它各個頂點的最短路徑。
*
* 參數說明：
* vs -- 起始頂點(start vertex)。即計算"頂點vs"到其它頂點的最短路徑。
* prev -- 前驅頂點數組。即，prev[i]的值是"頂點vs"到"頂點i"的最短路徑所經歷的全部頂點中，位於"頂點i"之前的那個頂點。
* dist -- 長度數組。即，dist[i]是"頂點vs"到"頂點i"的最短路徑的長度。
* 關鍵要點：
* 1.避免形成迴路可以boolean數組進行訪問控制，這點和深度遍歷、廣度遍歷是類似的
* 2.貪心 每次選取已經聯通的點所能聯通邊的節點 這和floyd順序獲取節點是最大的不同
*/
public void dijkstra(int vs, int[] prev, int[] dist) {
// flag[i]=true表示"頂點vs"到"頂點i"的最短路徑已成功獲取
boolean[] flag = new boolean[mVexs.length];
// 初始化
for (int i = 0; i < mVexs.length; i++) {
flag[i] = false; // 頂點i的最短路徑還沒獲取到。
prev[i] = 0; // 頂點i的前驅頂點爲0。
dist[i] = mMatrix[vs][i]; // 頂點i的最短路徑爲"頂點vs"到"頂點i"的權。
}
// 對"頂點vs"自身進行初始化
flag[vs] = true;
dist[vs] = 0;
// 遍歷mVexs.length-1次；每次找出一個頂點的最短路徑。
int k = 0;
for (int i = 0; i < mVexs.length; i++) {
// 尋找當前最小的路徑；
// 即，在未獲取最短路徑的頂點中，找到離vs最近的頂點(k)。
int min = INF;
for (int j = 0; j < mVexs.length; j++) {
if (flag[j] == false && dist[j] < min) {
min = dist[j];
k = j;
}
}
// 標記"頂點k"爲已經獲取到最短路徑
flag[k] = true;
// 修正當前最短路徑和前驅頂點
// 即，當已經"頂點k的最短路徑"之後，更新"未獲取最短路徑的頂點的最短路徑和前驅頂點"。
for (int j = 0; j < mVexs.length; j++) {
int tmp = (mMatrix[k][j] == INF ? INF : (min + mMatrix[k][j]));
if (flag[j] == false && (tmp < dist[j])) {
dist[j] = tmp;
prev[j] = k;
}
}
}
// 打印dijkstra最短路徑的結果
System.out.printf("dijkstra(%c): \n", mVexs[vs]);
for (int i = 0; i < mVexs.length; i++){
System.out.printf("shortest(%c, %c)=%d ", mVexs[vs], mVexs[i], dist[i]);
//打印最短路徑具體過程
System.out.print( mVexs[i]+" ");
int x=prev[i];
while(x!=0){
System.out.print(mVexs[x]+" ");
x=prev[x];
}
System.out.print(mVexs[vs]+"\n");
}
}
public static void main(String[] args) {
char[] vexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
int matrix[][] = {
/*A*//*B*//*C*//*D*//*E*//*F*//*G*/
/*A*/ {0, 12, INF, INF, INF, 16, 14},
/*B*/ {12, 0, 10, INF, INF, 7, INF},
/*C*/ {INF, 10, 0, 3, 5, 6, INF},
/*D*/ {INF, INF, 3, 0, 4, INF, INF},
/*E*/ {INF, INF, 5, 4, 0, 2, 8},
/*F*/ {16, 7, 6, 10000, 2, 0, 9},
/*G*/ {14, INF, INF, INF, 8, 9, 0}};
MatrixUDG pG;
// 自定義"圖"(輸入矩陣隊列)
//pG = new MatrixUDG();
// 採用已有的"圖"
pG = new MatrixUDG(vexs, matrix);
//pG.print(); // 打印圖
int[] prev = new int[pG.mVexs.length];
int[] dist = new int[pG.mVexs.length];
// dijkstra算法獲取"第4個頂點"到其它各個頂點的最短距離
pG.dijkstra(3, prev, dist);
}
}
