允许最大步数的 Floyd Warshall 算法

Question

在解决具有 n 个节点的有向加权图的最短路径问题时，是否可以修改 Floyd-Warshall 算法，使得每条最短路径的长度不超过 m 步骤？更准确地说，对于每一对节点 i 和 j，你将要找到从 i 到 j 包含不超过 m 个节点。时间复杂度是否仍然保持O(n³)？

Answer 1

同时，我发现了一个 O(n³logm) 算法来找到最短的所有对具有 n 个节点的图的路径（ASPP）问题，使得没有路径包含超过 m 个节点。

给定两个 n x n 矩阵，比如 A = [a_ij ] 和 B = [b_ij]，他们的distance product 是n x n 矩阵 C = [c_ij] = A x B，定义为c_ij = min_{1≤k ≤n} {a_ik + b _kj}。

这与 ASPP 有以下关系。给定图中距离的加权矩阵E，Eⁿ是所有对最短路径的矩阵。如果我们添加约束，即没有路径包含超过 m 个节点，那么矩阵 E^m 就是 ASPP 的解决方案.由于计算能力可以在 O(logm) 时间内找到，这给了我们一个 O(n3logm) 算法。

Here，在某些特殊情况下，可能会找到更快的算法来计算矩阵的距离积，但微不足道的一个O(n^{3 sup>) 对我来说已经足够了，因为总时间几乎与 Floyd-Warshall 方法一样快。}

Answer 2

是的，是的。

• 算法的每次迭代都会增加您搜索路径的单个长度单位。因此，如果您将迭代次数限制为 m，那么您会发现一条长度最多为 m 的路径。
• 在 m -> n 的最坏情况下，复杂度将保持 O(n^3)。但是，更精确的估计应该是 O(m * n^2)。

Answer 3

我相信这可以通过不同的数据结构（可以让您跟踪步数的数据结构）来完成？

由于 Floyd-Warshall 通常使用连接矩阵（其中矩阵 [j][k] 表示节点 j 和 k 之间的距离）来完成，因此我们可以不将该矩阵设为整数，而是将其设为具有两个整数的结构：两个节点之间的距离和它们之间的步数。

我用 C++ 写了一些东西来解释我的意思：

#define INFINITY 9999999

struct floydEdge
{
    int weight;
    int steps;
};

floydEdge matrix[10][10];

int main()
{
    //We initialize the matrix
    for(int j=0;j<10;j++)
    {
        for(int k=0;k<10;k++)
        {
            matrix[j][k].weight=INFINITY;
            matrix[j][k].steps=0;
        }
    }

    //We input some weights
    for(int j=0;j<10;j++)
    {
        int a, b;
        cin>>a>>b;
        cin>>matrix[a][b].weight;
        matrix[b][a].weight=matrix[a][b].weight;
        matrix[a][b].steps=matrix[b][a].steps=1;
    }

    //We do the Floyd-Warshall, also checking for the step count as well as the weights
    for(int j=0;j<10;j++)
    {
        for(int k=0;k<10;k++)
        {
            for(int i=0;i<10;i++)
            {
                //We check if there is a shorter path between nodes j and k, using the node i. We also check if that path is shorter or equal to 4 steps.
                if((matrix[j][k].weight > matrix[j][i].weight + matrix[i][k].weight) && (matrix[j][i].steps+matrix[i][k].steps<=4))
                {
                    matrix[j][k].weight=matrix[k][j].weight=matrix[j][i].weight + matrix[i][k].weight;
                    matrix[j][k].steps=matrix[k][j].steps=matrix[j][i].steps+matrix[i][k].steps;
                }
                //If the path is not shorter, we can also check if the path is equal BUT requires less steps than the path we currently have.
                else if((matrix[j][k].weight == matrix[j][i].weight + matrix[i][k].weight) && (matrix[j][i].steps+matrix[i][k].steps<matrix[j][k].steps))
                {
                    matrix[j][k].weight=matrix[k][j].weight=matrix[j][i].weight + matrix[i][k].weight;
                    matrix[j][k].steps=matrix[k][j].steps=matrix[j][i].steps+matrix[i][k].steps;
                }
            }
        }
    }
    return 0;
}

我相信（但我不完全确定）这可以完美地工作（总是为所有节点之间提供最短路径）。试试看，告诉我！