算法——弗洛伊德(Floyd)算法

弗洛伊德算法简介

1) 和 Dijkstra 算法一样，弗洛伊德(Floyd)算法也是一种用于寻找给定的加权图中顶点间最短路径的算法。

2) 弗洛伊德算法(Floyd)计算图中各个顶点之间的最短路径

3) 迪杰斯特拉算法用于计算图中某一个顶点到其他顶点的最短路径。

4) 弗洛伊德算法 VS 迪杰斯特拉算法：迪杰斯特拉算法通过选定的被访问顶点，求出从出发访问顶点到其他顶点的最短路径；弗洛伊德算法中每一个顶点都是出发访问点，所以需要将每一个顶点看做被访问顶点，求出从每 一个顶点到其他顶点的最短路径。

弗洛伊德算法分析

算法基本流程

1) 设置顶点 vi 到顶点 vk 的最短路径已知为 Lik，顶点 vk 到 vj 的最短路径已知为 Lkj，顶点 vi 到 vj 的路径为 Lij， 则 vi 到 vj 的最短路径为：min((Lik+Lkj),Lij)，vk 的取值为图中所有顶点（作为中间顶点），则可获得 vi 到 vj 的最短路径。

2) 至于 vi 到 vk 的最短路径 Lik 或者 vk 到 vj 的最短路径 Lkj，是以同样的方式获得。

3）通过迭代遍历即可得到最短路径。

举例说明

1) 胜利乡有 7 个村庄(A, B, C, D, E, F, G)

2) 各个村庄的距离用边线表示(权) ，比如 A – B 距离 5 公里

3) 问：如何计算出各村庄到 其它各村庄的最短距离?

分析

1.在还未迭代时，首先要给出初始各个顶点的距离表，根据村庄的图即可获取，其实就是图的邻接矩阵，其中未连通的用极大值表示，如用N表示。初始各顶点之间的距离表如下：

2.初始顶点的前驱节点表也要列出来，便于后续遍历迭代寻找新的前驱节点，初始情况下，顶点的前驱节点就是自己本身，初始顶点前驱节点表如下：

3.接着开始循环寻找：

第一轮循环中，以 A(下标为：0)作为中间顶点【即把 A 作为中间顶点的所有情况都进行遍历, 就会得到更新距离表 和 前驱关系】， 距离表和前驱关系更新为新的情况，分析如下：

        1) 以 A 顶点作为中间顶点是，B->A->C 的距离由 N->9，同理 C 到 B；C->A->G 的距离由 N->12，同理 G 到 C，因此将距离值替换成较小的距离值，并将前驱节点进行更新。

替换更新过程如下：

得到新的距离表和前驱节点表如下：

         2) 接着，更换中间顶点，循环执行操作，直到所有顶点都作为中间顶点更新后，计算结束。

后续循环更新的过程如下图分析：

通过上述图解可以发现，遍历得到每个顶点到其他顶点的最短路径，需要三层循环，因此弗洛伊德算法的复杂度为： O(n^3)，时间复杂度较高。

代码实现

代码如下：

1. package com.study.Floyd;

3. import java.util.Arrays;

5. /**

6. * @author 漂亮小小

7. * @version 1.0

8. * 弗洛伊德算法

9. */

10. public class FloydAlgorithm {

11. public static void main(String[] args) {

12. //测试图是否创建成功

13. char[] vertex = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};

14. //创建原始邻接矩阵

15. int[][] matrix = new int[vertex.length][vertex.length];

16. final int N = 65535;//表示最大，走不通

17. matrix[0] = new int[]{0, 5, 7, N, N, N, 2};

18. matrix[1] = new int[]{5, 0, N, 9, N, N, 3};

19. matrix[2] = new int[]{7, N, 0, N, 8, N, N};

20. matrix[3] = new int[]{N, 9, N, 0, N, 4, N};

21. matrix[4] = new int[]{N, N, 8, N, 0, 5, 4};

22. matrix[5] = new int[]{N, N, N, 4, 5, 0, 6};

23. matrix[6] = new int[]{2, 3, N, N, 4, 6, 0};

24. //创建图对象

25. Graph graph = new Graph(vertex.length, matrix, vertex);

26. graph.show();

28. //调用弗洛伊德算法

29. System.out.println("===========弗洛伊德算法后的最短路径===============");

30. graph.floyd();

31. graph.show();

32. }

33. }

35. //创建图

36. class Graph {

37. private char[] vertex;//存放顶点的数组

38. private int[][] dis;//存放 从各个顶点出发，到其他顶点的距离；；最终结果存放在这

39. private int[][] pre;//保存到达目标顶点的前驱顶点 动态变化，，相当于存放中间节点

41. //构造器

43. /**

44. * @param length 大小

45. * @param matrix 初始邻接矩阵

46. * @param vertex 顶点数组

47. */

48. public Graph(int length, int[][] matrix, char[] vertex) {

49. this.vertex = vertex;

50. this.dis = matrix;//接收邻接矩阵

51. this.pre = new int[length][length];//动态生成 new

52. //对前驱pre初始化，存放前驱顶点的下标

53. for (int i = 0; i < length; i++) {

54. Arrays.fill(pre[i], i);//下标初始化就是自己

55. }

56. }

58. //显示pre数组和dis数组

59. public void show() {

60. //为了提高可读性，优化一下

61. char[] vertex = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};

62. for (int k = 0; k < dis.length; k++) {

63. //先将pre数组输出

64. //pre数组的一行数据

65. for (int i = 0; i < dis.length; i++) {

66. System.out.print(vertex[pre[k][i]] + " ");

67. }

68. System.out.println();

69. //dis数组的一行数据

70. for (int i = 0; i < dis.length; i++) {

71. System.out.print("（" + vertex[k] + "-" + vertex[i] + "最短路径" + dis[k][i] + "） ");

72. }

73. System.out.println();//换行

74. }

75. }

77. //弗洛伊德算法

78. public void floyd() {

79. int len = 0;//保存距离

80. //3层for循环

81. //对中间顶点的遍历 k是中间顶点的下标

82. for (int k = 0; k < dis.length; k++) {//中间顶点 依次为 A-B-C-D-E-F-G

83. for (int i = 0; i < dis.length; i++) {//出发顶点 依次为 A-B-C-D-E-F-G

84. for (int j = 0; j < dis.length; j++) {//终点 依次为 A-B-C-D-E-F-G

85. len = dis[i][k] + dis[k][j];//出发到中间到终点的距离

86. if(len < dis[i][j]) {//len < dis[i][j]表示当前距离小，则要更新距离

87. dis[i][j] = len;//更新

88. pre[i][j] = pre[k][j];//更新前驱顶点

89. }

90. }

91. }

92. }

94. }

95. }

结果

算法——弗洛伊德(Floyd)算法_弗洛伊德算法-CSDN博客