基本概述

• 弗洛伊德算法介绍
  
• 图解分析
  
  
• 算法步骤
  
  
  
  
  

Python实现

# 弗洛伊德算法

class Graph(object):
    def __init__(self, length: int, matrix: [], vertex: []):
        """
        :param length: 大小
        :param matrix: 邻接矩阵
        :param vertex: 顶点数组
        """
        # 保存，从各个顶点出发到其它顶点的距离，最后的结果，也保留在该数组
        self.dis = matrix
        # 保存到达目标顶点的前驱顶点
        self.pre = [[0 for col in range(length)] for row in range(length)]
        self.vertex = vertex
        # 对 pre数组进行初始化，存放的是前驱顶点的下标
        for i in range(length):
            for j in range(length):
                self.pre[i][j] = i

    # 显示pre数组和dis数组
    def show_graph(self):
        # 为了显示便于阅读，优化一下
        for k in range(len(self.dis)):
            # 先将pre数组输出的一行
            for i in range(len(self.dis)):
                # print(self.pre[k][i], end=" ")
                print(self.vertex[self.pre[k][i]], end=" ")
            # 输出dis数组的一行数据
            print()
            for i in range(len(self.dis)):
                print('({}到{}的最短路径是{})'.format(self.vertex[k], self.vertex[i], self.dis[k][i]), end=" ")
            print()
            print()

    # 佛洛依德算法
    def floyd(self):
        length: int = 0  # 变量保存距离
        # 对中间顶点的遍历,k 就是中间顶点的下标
        for k in range(len(self.dis)):  # ['A', 'B', 'C', 'D', 'E', 'F', 'G']
            # 从 i顶点开始出发['A', 'B', 'C', 'D', 'E', 'F', 'G']
            for i in range(len(self.dis)):
                # 到达j顶点 ['A', 'B', 'C', 'D', 'E', 'F', 'G']
                for j in range(len(self.dis)):
                    length = self.dis[i][k] + self.dis[k][j]  # 求出从i 顶点出发，经过k中间顶点，到达j顶点距离
                    if length < self.dis[i][j]:  # 如果length 小于dis[i][j]
                        self.dis[i][j] = length  # 更新距离
                        self.pre[i][j] = self.pre[k][j]  # 更新前驱顶点


if __name__ == '__main__':
    vertex: [] = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
    # 邻接矩阵
    matrix: [] = [[0 for col in range(len(vertex))] for row in range(len(vertex))]
    # 用来表示一个极大的数
    F: float = float('inf')
    matrix[0] = [0, 5, 7, F, F, F, 2]
    matrix[1] = [5, 0, F, 9, F, F, 3]
    matrix[2] = [7, F, 0, F, 8, F, F]
    matrix[3] = [F, 9, F, 0, F, 4, F]
    matrix[4] = [F, F, 8, F, 0, 5, 4]
    matrix[5] = [F, F, F, 4, 5, 0, 6]
    matrix[6] = [2, 3, F, F, 4, 6, 0]
    g = Graph(len(vertex), matrix, vertex)
    # 调用弗洛伊德算法
    g.floyd()
    g.show_graph()
'''输出结果
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) 
'''