概述
- 弗洛伊德算法(Floyd’s algorithm)也是最短路径算法, 用于计算图中各个顶点之间的最短路径. 与迪杰斯特拉算法(Dijkstra’s algorithm)不同的是, 迪杰斯特拉算法是指定某一个顶点到其它顶点的最短路径, 而弗洛伊德算法是每一个(所有)顶点到其它顶点的最短路径
最短路径问题
- 胜利乡有7个村庄(A,B,C,D,E,F,G)
- 各个村庄的距离用边线权值来表示, 比如 A-B距离5公里
-
计算出各个村庄到其它各个村庄的最短距离
-
代码实现
public class FloydAlgorithmApp {
/** 定义顶点*/
private static final char[] vertexes = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
/** 定义常量, 9999表示某顶点间不连通*/
private static final int N = 9999;
public static void main(String[] args) {
/** 邻接矩阵*/
int[][] matrix = new int[vertexes.length][vertexes.length];
matrix[0] = new int[]{0, 5, 7, N, N, N, 2};
matrix[1] = new int[]{5, 0, N, 9, N, N, 3};
matrix[2] = new int[]{7, N, 0, N, 8, N, N};
matrix[3] = new int[]{N, 9, N, 0, N, 4, N};
matrix[4] = new int[]{N, N, 8, N, 0, 5, 4};
matrix[5] = new int[]{N, N, N, 4, 5, 0, 6};
matrix[6] = new int[]{2, 3, N, N, 4, 6, 0};
FloydGraph graph = new FloydGraph(vertexes, matrix);
/** 求出最短路径*/
graph.floyd();
/** 打印结果*/
graph.show();
}
}
class FloydGraph {
/** 顶点数组*/
private char[] vertexes;
/** 邻接矩阵: 保存各个顶点之间距离, 最后求出的结果, 也保留在该数组*/
private int[][] matrix;
/** 保存到达目标顶点的前驱顶点*/
private int[][] preVertexes;
/**
* @param vertexes 顶点数组
* @param matrix 邻接矩阵
*/
public FloydGraph(char[] vertexes, int[][] matrix) {
this.vertexes = vertexes;
this.matrix = matrix;
this.preVertexes = new int[vertexes.length][vertexes.length];
/** 初始化前驱顶点数组, 存放前驱顶点的下标*/
for (int i = 0; i < vertexes.length; i++) {
Arrays.fill(preVertexes[i], i);
}
}
/** 求出最短路径(通过弗洛伊德算法实现的)*/
public void floyd() {
int distance = 0;
/** 对中间顶点遍历, k就是中间顶点的下标 [A, B, C, D, E, F, G]*/
for (int k = 0; k < matrix.length; k++) {
/** 从 i顶点开始出发 [A, B, C, D, E, F, G]*/
for (int i = 0; i < matrix.length; i++) {
/** 到达 j顶点 [A, B, C, D, E, F, G]*/
for (int j = 0; j < matrix.length; j++) {
/** (从 i顶点出发到 k中间顶点的距离) + (k中间顶点到 j顶点的距离)
* 当 k作为中间顶点 A时
* 1. C-A-G(9)
* 2. C-A-B(12)
* 3. G-A-B(7)*/
distance = matrix[i][k] + matrix[k][j];
/** 如果 distance小于直连的距离(matrix[i][j])
* 当 G-A-B(7)时, 由于 G到B本来是3结果绕过A, 会导致变的更长就不会被更新*/
if (distance < matrix[i][j]) {
/** 更新距离*/
matrix[i][j] = distance;
/** 更新前驱顶点*/
preVertexes[i][j] = preVertexes[k][j];
}
}
}
}
}
/** 打印结果*/
public void show() {
for (int k = 0; k < matrix.length; k++) {
/** 打印前驱顶点数组的一行*/
for (int i = 0; i < matrix.length; i++) {
System.out.print(vertexes[preVertexes[k][i]] + " ");
}
/** 打印邻接矩阵指定行数据*/
for (int i = 0; i < matrix.length; i++) {
System.out.print("(" + vertexes[k] + "到 " + vertexes[i] + "的最短路径是" + matrix[k][i] + ") ");
}
System.out.println();
}
}
}
输出:
A A A F G G A (A到 A的最短路径是0) (A到 B的最短路径是5) (A到 C的最短路径是7) (A到 D的最短路径是12) (A到 E的最短路径是6) (A到 F的最短路径是8) (A到 G的最短路径是2)
B B A B G G B (B到 A的最短路径是5) (B到 B的最短路径是0) (B到 C的最短路径是12) (B到 D的最短路径是9) (B到 E的最短路径是7) (B到 F的最短路径是9) (B到 G的最短路径是3)
C A C F C E A (C到 A的最短路径是7) (C到 B的最短路径是12) (C到 C的最短路径是0) (C到 D的最短路径是17) (C到 E的最短路径是8) (C到 F的最短路径是13) (C到 G的最短路径是9)
G D E D F D F (D到 A的最短路径是12) (D到 B的最短路径是9) (D到 C的最短路径是17) (D到 D的最短路径是0) (D到 E的最短路径是9) (D到 F的最短路径是4) (D到 G的最短路径是10)
G G E F E E E (E到 A的最短路径是6) (E到 B的最短路径是7) (E到 C的最短路径是8) (E到 D的最短路径是9) (E到 E的最短路径是0) (E到 F的最短路径是5) (E到 G的最短路径是4)
G G E F F F F (F到 A的最短路径是8) (F到 B的最短路径是9) (F到 C的最短路径是13) (F到 D的最短路径是4) (F到 E的最短路径是5) (F到 F的最短路径是0) (F到 G的最短路径是6)
G G A F G G G (G到 A的最短路径是2) (G到 B的最短路径是3) (G到 C的最短路径是9) (G到 D的最短路径是10) (G到 E的最短路径是4) (G到 F的最短路径是6) (G到 G的最短路径是0)
- 演变过程图示
- C-A-G(9)
- C-A-B(12)
- G-A-B(7) - 此时由于 G到B本来是3结果绕过A, 会导致变的更长就不会被更新
* 初始顶点间距离表: A作为中间顶点遍历得到更新后的距离表
* 初始顶点与前驱关系表: A作为中间顶点遍历一次得到更新后的前驱关系表
如果您觉得有帮助,欢迎点赞哦 ~ 谢谢!!