Question

我已经实现了Floyd-Warshall来返回每对节点/顶点之间的最短路径的距离以及每个节点/顶点之间的单个最短路径。

有没有办法让它返回每条最短的路径，即使每条节点对有多条最短路径的路径？（我只是想知道我是否在浪费时间尝试）

Answer 1

如果您只需要计算存在多少个不同的最短路径，除count数组外，还可以保留shortestPath数组。这是从wiki快速修改伪代码。

procedure FloydWarshall ()
    for k := 1 to n
        for i := 1 to n
            for j := 1 to n
                if path[i][j] == path[i][k]+path[k][j] and k != j and k != i
                    count[i][j] += 1;
                else if path[i][j] > path[i][k] + path[k][j]
                    path[i][j] = path[i][k] + path[k][j]
                    count[i][j] = 1

如果您需要一种方法来查找所有路径，则可以为每对存储vector/arraylist类似的结构以进行展开和折叠。以下是来自同一wiki的伪代码的修改。

procedure FloydWarshallWithPathReconstruction ()
    for k := 1 to n
        for i := 1 to n
            for j := 1 to n
                if path[i][k] + path[k][j] < path[i][j]
                    path[i][j] := path[i][k]+path[k][j];
                    next[i][j].clear()
                    next[i][j].push_back(k) // assuming its a c++ vector
                else if path[i][k] + path[k][j] == path[i][j] and path[i][j] != MAX_VALUE and k != j and k != i
                    next[i][j].push_back(k)

注意：如果k==j或k==i，则表示您正在检查path[i][i]+path[i][j]或path[i][j]+path[j][j]，两者都应该等于path[i][j]不会被推入next[i][j]。

应修改路径重建以处理vector。在这种情况下，计数将是每个vector的大小。以下是来自同一wiki的伪代码（python）的修改。

procedure GetPath(i, j):
    allPaths = empty 2d array
    if next[i][j] is not empty:
        for every k in next[i][j]:
            if k == -1: // add the path = [i, j]
                allPaths.add( array[ i, j] ) 
            else: // add the path = [i .. k .. j]
                paths_I_K = GetPath(i,k) // get all paths from i to k
                paths_K_J = GetPath(k,j) // get all paths from k to j
                for every path between i and k, i_k in paths_I_K:
                    for every path between k and j, k_j in paths_K_J:
                        i_k = i_k.popk() // remove the last element since that repeats in k_j
                        allPaths.add( array( i_k + j_k) )

    return allPaths

注意：path[i][j]是邻接列表。初始化path[i][j]时，您还可以通过向数组添加next[i][j]来初始化-1。例如，next[i][j]的初始化将是

for every edge (i,j) in graph:
   next[i][j].push_back(-1)

这会将边缘作为最短路径本身。你必须在路径重建中处理这个特殊情况，这就是我在GetPath中所做的。

编辑：“MAX_VALUE”是距离数组中的初始化值。

Answer 2

在某些情况下，当前批准的答案中的“计数”功能会失败。更完整的解决方案是：

procedure FloydWarshallWithCount ()
for k := 1 to n
    for i := 1 to n
        for j := 1 to n
            if path[i][j] == path[i][k]+path[k][j]
                count[i][j] += count[i][k] * count[k][j]
            else if path[i][j] > path[i][k] + path[k][j]
                path[i][j] = path[i][k] + path[k][j]
                count[i][j] = count[i][k] * count[k][j]

这是因为对于任何三个顶点i，j和k，可能存在从i到k到j的多个最短路径。例如，在图表中：

       3             1
(i) -------> (k) ---------> (j)
 |            ^
 |            |
 | 1          | 1
 |     1      |
(a) -------> (b)

从i到j到k有两条路径。 count[i][k] * count[k][j]找到从i到k的路径数，以及从k到j的路径数，并将它们相乘以找到路径数i - ＆gt; k - ＆gt;学家

Floyd-Warshall：所有最短的路径

2 个答案: