Algorithm Floyd–Warshall算法

有没有一个简单的解释来解释为什么这个片段会找到两个顶点之间的最短距离

for (k = 0; k < n; ++k)
  for (i = 0; i < n; ++i)
    for (j = 0; j < n; ++j)
      if (d[i][k] + d[k][j] < d[i][j])
        d[i][j] = d[i][k] + d[k][j]

但事实并非如此

for (i = 0; i < n; ++i)
  for (j = 0; j < n; ++j)
    for (k = 0; k < n; ++k)
      if (d[i][k] + d[k][j] < d[i][j])
        d[i][j] = d[i][k] + d[k][j]

---

因为k是第二个代码片段中最里面的一个，因为其思想是通过在每一步尝试通过节点k来改进每个i-j路径，从而使路径变得更好

符号不重要，如果需要，可以使用i，j，k作为循环变量，而不是k，i，j，但是必须记住上面的逻辑。在这种情况下，您将希望通过在每个步骤中通过i来尝试改进j-k路径：

for i = 0, n
  for j = 0, n
    for k = 0, n
      if d[j, i] + d[i, k] < d[j, k]
        d[j, k] = d[j, i] + d[i, k]

---

你不能在不改变条件的情况下对for循环重新排序，因为你会得到一个不同的算法——谁知道它会做什么呢。

因为这个想法是通过在每一步尝试通过节点k来改进每个i-j路径，从而使路径变得更好

符号不重要，如果需要，可以使用i，j，k作为循环变量，而不是k，i，j，但是必须记住上面的逻辑。在这种情况下，您将希望通过在每个步骤中通过i来尝试改进j-k路径：

for i = 0, n
  for j = 0, n
    for k = 0, n
      if d[j, i] + d[i, k] < d[j, k]
        d[j, k] = d[j, i] + d[i, k]

---

你不能在不改变条件的情况下对for循环重新排序，因为你得到了一个不同的算法——谁知道它会做什么。

我找到了第二个有缺陷算法的反例。 当i=0，j=1时，它将试图找到一个中介，但没有。 然后，当中介体可用于i=0、j=1时，不再再次检查它。

---

我找到了第二个有缺陷算法的反例。 当i=0，j=1时，它将试图找到一个中介，但没有。 然后，当中介体可用于i=0、j=1时，不再再次检查它。 在

for (k = 0; k < n; ++k)
  for (i = 0; i < n; ++i)
    for (j = 0; j < n; ++j)
      if (d[i][k] + d[k][j] < d[i][j])
        d[i][j] = d[i][k] + d[k][j]

更重要的是，从这些路径中，你选择了最好的放松方式

if (d[i][k] + d[k][j] < d[i][j])
        d[i][j] = d[i][k] + d[k][j]

在

更重要的是，从这些路径中，你选择了最好的放松方式

if (d[i][k] + d[k][j] < d[i][j])
        d[i][j] = d[i][k] + d[k][j]

基本上，当循环K中有K值时，这意味着要添加另一条边，从i->j开始的所有可能方式都会使用edges1->K-1进行更新。 然后插入另一条边K，再次检查是否有任何方法可以使用该边以更便宜的方式从i->j开始。所以你写d[i][j]=心[i][j]，d[i][k]+d[k][j]

所以如果你想写

  for(int i=0;i<n;i++)
   for(int j=0;j<n;j++)
     for(int k=0;k<n;k++)

你的更新应该是d[j][k]=mind[j][k]，d[j][i]+d[i][k]

基本上当你在循环k中有k值时，这意味着你将要添加另一条边，从i->j开始的所有可能的方式都使用edges1->k-1更新。 然后插入另一条边K，再次检查是否有任何方法可以使用该边以更便宜的方式从i->j开始。所以你写d[i][j]=心[i][j]，d[i][k]+d[k][j]

所以如果你想写

  for(int i=0;i<n;i++)
   for(int j=0;j<n;j++)
     for(int k=0;k<n;k++)

---

你的更新应该是d[j][k]=mind[j][k]，d[j][i]+d[i][k]

你可以用铅笔和观察邻接矩阵变换来解决不确定性。看看中的经典实现，你可以用铅笔和观察邻接矩阵变换来解决不确定性。查看中的经典实现