最多有 k 个边的 Floyd-Warshall

如何解决最多有 k 个边的 Floyd-Warshall

我对 APSP 固件算法的变体感兴趣。具体来说，如何计算最多k条边的最短路径。我能够获得工作距离，但路径没有返回正确的顶点。

这是我的程序：

def floyd_warshall_at_k(adj,max_edge):
    n = adj.shape[0]
    dp = np.ones((n,n,max_edge),dtype=float) * math.inf
    pred = np.ones((n,dtype=int) * -1

    for i,j in itertools.product(range(n),range(n)):
        dp[i][j][:] = adj[i][j]
        if i == j:
            dp[i][j][:] = 0
            pred[i][j][:] = j
        elif adj[i][j] != math.inf:
            pred[i][j][:] = j

    for e,i,j,k in itertools.product(range(1,range(n),range(n)):
        if adj[i][k] == math.inf or dp[k][j][e - 1] == math.inf:
            continue

        if i == k:
            continue

        w = adj[i][k] + dp[k][j][e - 1]

        if j == 5 and i in [5]:
            print(f"k={k},i={i},j={j},e={e},{pred[i][j][e]} --> pred[i={i}][k={k}][e={e}-1] = {pred[i][k][e-1]} ({adj[i][k]} + {dp[k][j][e - 1]} < {dp[i][j][e]},{w < dp[i][j][e]})")

        if w < dp[i][j][e]:
            dp[i][j][e] = w
            pred[i][j][e] = pred[i][k][e-1]

    return dp,pred

作为我传入的示例，

adj = np.array([
    [1,1,1/1,5,1/2],[1/1,0],[0,[1,[1/5,1/5,.1],[2,1/.1,1],])

adj = -np.log(adj)
adj = np.round(adj,4)
np.fill_diagonal(adj,0)

dist,pred = floyd_warshall_at_k(adj,10)

回来了，

dist,10)
print(np.round(np.exp(-dist[2][5])))
print(pred[0][5])

$ [  0.   0.   0.  25.  25.  25.  25. 125. 125. 125.]
$ [-1  4  4  1  1  4  4  4  4  4]

pred[0][5] 应该是 4s（除了第一个 -1）。

事实上它应该通过，

assert pred[2][5][3] == 1 or pred[2][5][3] == 3,pred[2][5][3]
assert pred[3][5][3] == 0 or pred[1][5][3] == 0,pred[3][5][3]
assert pred[0][5][3] == 4,pred[0][5][3]
assert pred[4][5][3] == 5,pred[4][5][3]
assert pred[5][5][3] == 5,pred[5][5][3]