1.迪杰斯特拉（Dijkstra）算法
是一种贪心算法，解决了某个源点到其余各点最短路径问题。
首先建立一个集合，初始化只有一个顶点。每次将当前集合的所有顶点（初始只有一个顶点）看成一个整体，找到集合外与集合距离最近的顶点，将其加入集合并检查是否修改路径距离（比较在集合内源点到达目标点中各个路径的距离，取最小值），以此类推，直到将所有点都加入集合中。得到的就是源点到达各顶点最短距离。时间复杂度为O(n^2)。
public static int[] dijkstra(int[][] arr, int start) {
int n = arr.length;
//保存start到其他各点的最短路径
int[] shortPath = new int[n];
//保存start到其他各点最短路径的字符串标识
String[] path = new String[n];
for (int i = 0; i < n; i++) {
path[i] = start + "-->" + i;
}
//标记当前该顶点的最短路径是否已求出，1表示以求出
int[] visited = new int[n];
//初始化，第一个顶点已求出
shortPath[start] = 0;
visited[start] = 1;
//要加入n-1个点
for (int count = 1; count < n; count++) {
//选出一个距离初始顶点start最近的未标记顶点
int k = -1;
int dmin = MAX_VALUE;
for (int i = 0; i < n; i++) {
//每次取未确定的顶点，判断出发点到顶点的距离
if (visited[i] == 0 && arr[start][i] < dmin) {
dmin = arr[start][i];
k = i;
}
}
// 将新选出的顶点标记为已求出最短路径，且到start的最短路径就是dmin
shortPath[k] = dmin;
visited[k] = 1;
//以k为中间点，修正从start到未访问各点的距离
for (int i = 0; i < n; i++) {
//如果'起始点到当前点距离' + '当前点到某点距离' <'起始点到某点距离'，则更新
if (visited[i] == 0 && arr[start][k] + arr[k][i] < arr[start][i]) {
arr[start][i] = arr[start][k] + arr[k][i];
path[i] = path[k] + "-->" + i;
}
}
}
for (int i = 0; i < n; i++) {
System.out.println("从" + start + "出发到" + i + "的最短路径为：" + path[i]);
}
return shortPath;
}
private final static int MAX = MAX_VALUE - 8;
private static int[][] arr = {
{0, 1, 5, MAX, MAX, MAX, MAX, MAX, MAX},
{1, 0, 3, 7, 5, MAX, MAX, MAX, MAX},
{5, 3, 0, MAX, 1, 7, MAX, MAX, MAX},
{MAX, 7, MAX, 0, 2, MAX, 3, MAX, MAX},
{MAX, 5, 1, 2, 0, 3, 6, 9, MAX},
{MAX, MAX, 7, MAX, 3, 0, MAX, 5, MAX},
{MAX, MAX, MAX, 3, 6, MAX, 0, 2, 7},
{MAX, MAX, MAX, MAX, 9, 5, 2, 0, 4},
{MAX, MAX, MAX, MAX, MAX, MAX, 7, 4, 0}
};
public static void main(String[] args) {
int[] shortPath = dijkstra(arr, 0);
for (int i = 0; i < shortPath.length; i++) {
System.out.println(shortPath[i]);
}
}
2.弗洛伊德（Floyd）算法
用于多源最短路径的求解，算出来的是所有的节点到其余各节点之间的最短距离。
首先初始化距离矩阵，然后从第一个点开始逐渐更新矩阵点值。 d[i][j]表示从i点到j点的距离。第k次更新时，判断d[i][k]+d[k][j]与d[i][j]的大小，如果前者小，则更新这个值，否则不变。
public static void floyd(int[][] arr) {
int length = arr.length;
//最短路径的集合
int[][] shortPathTable = new int[length][length];
//path[i][j]= x表明ij i->j的最短距离要经过x
int[][] path = new int[length][length];
for (int i = 0; i < length; i++) {
for (int j = 0; j < length; j++) {
shortPathTable[i][j] = arr[i][j];
path[i][j] = j;
}
}
for (int i = 0; i < length; i++) {
for (int j = 0; j < length; j++) {
for (int k = 0; k < length; k++) {
//如果经过下标为i对的顶点比原两顶点间路径更短，则更新为小的那个
if (shortPathTable[j][i] != MAX && shortPathTable[i][k] != MAX) {
if (shortPathTable[j][k] > shortPathTable[j][i] + shortPathTable[i][k]) {
shortPathTable[j][k] = shortPathTable[j][i] + shortPathTable[i][k];
path[j][k] = path[j][i];
}
}
}
}
}
for (int i = 0; i < length; i++) {
System.out.print("最短路径：");
for (int j = 0; j < length; j++) {
System.out.print(path[i][j] + " ");
}
System.out.println();
}
}
private final static int MAX = MAX_VALUE - 8;
private static int[][] arr = {
{0, 1, 5, MAX, MAX, MAX, MAX, MAX, MAX},
{1, 0, 3, 7, 5, MAX, MAX, MAX, MAX},
{5, 3, 0, MAX, 1, 7, MAX, MAX, MAX},
{MAX, 7, MAX, 0, 2, MAX, 3, MAX, MAX},
{MAX, 5, 1, 2, 0, 3, 6, 9, MAX},
{MAX, MAX, 7, MAX, 3, 0, MAX, 5, MAX},
{MAX, MAX, MAX, 3, 6, MAX, 0, 2, 7},
{MAX, MAX, MAX, MAX, 9, 5, 2, 0, 4},
{MAX, MAX, MAX, MAX, MAX, MAX, 7, 4, 0}
};
public static void main(String[] args) {
floyd(arr);
}