所有对最短路径的约翰逊算法 | 执行

简介

约翰逊算法是一种用于寻找所有对最短路径的算法，它利用了弗洛伊德算法和贝尔曼-福德算法的思想。约翰逊算法首先使用贝尔曼-福德算法对图进行一次变换，然后使用弗洛伊德算法来计算最短路径。这个算法的时间复杂度为O(n^2 * log n + n * m)，其中n是节点数，m是边数。

算法过程

1. 对图进行一次变换，使得所有的边权都为非负数
2. 对变换后的图运行弗洛伊德算法，计算所有对节点之间的最短路径
3. 对于每个节点u和每个邻接节点v，计算新的边权：w(u,v) = w(u,v) + h[u] - h[v]，其中h[u]是从源节点到节点u的最短路径长度
4. 对变换后的图运行弗洛伊德算法，再次计算所有对节点之间的最短路径，这次得到的就是最终的结果

代码示例

def johnson(graph):
    n = len(graph)

    # Step 1: 对图进行变换
    new_graph = [[0] * (n + 1) for _ in range(n + 1)]
    for i in range(1, n + 1):
        for j in range(1, n + 1):
            new_graph[i][j] = graph[i - 1][j - 1]

    for i in range(1, n + 1):
        new_graph[0][i] = 0
    
    # Step 2: 运行弗洛伊德算法
    dist = [[float('inf') for _ in range(n + 1)] for _ in range(n + 1)]
    for i in range(1, n + 1):
        for j in range(1, n + 1):
            dist[i][j] = new_graph[i][j]
    
    for k in range(1, n + 1):
        for i in range(1, n + 1):
            for j in range(1, n + 1):
                dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])

    # Step 3: 计算新的边权
    h = [float('inf')] * (n + 1)
    for i in range(1, n + 1):
        h[i] = dist[0][i]
    for i in range(1, n + 1):
        for j in range(1, n + 1):
            if new_graph[i][j] != float('inf'):
                new_graph[i][j] = new_graph[i][j] + h[i] - h[j]

    # Step 4: 运行弗洛伊德算法得到最终结果
    new_dist = [[float('inf') for _ in range(n)] for _ in range(n)]

    for i in range(n):
        for j in range(n):
            new_dist[i][j] = new_graph[i + 1][j + 1]

    for k in range(n):
        for i in range(n):
            for j in range(n):
                new_dist[i][j] = min(new_dist[i][j], new_dist[i][k] + new_dist[k][j])

    for i in range(n):
        for j in range(n):
            if new_dist[i][j] == float('inf'):
                new_dist[i][j] = -1

    return new_dist

以上是一个Python实现的约翰逊算法代码示例。在输入一个n x n的邻接矩阵表示一个有向图之后，这个算法会返回一个n x n的矩阵，表示所有对节点之间的最短路径。在实现时，我们使用了Python的列表来表示矩阵，并且将所有的inf值都用-1代替了，以便于输出结果。