NEUQ-ACM周报（最短路径）

B3647 【模板】Floyd - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

#define _CRT_SECURE_NO_WARNINGS 1
#define inf 0x3f3f3f3f//可以当作无穷大使用
#include<iostream>
#include <stdio.h>
#include <algorithm>
#include<limits.h>
using namespace std;

int Map[105][105];

int main()
{
    int n, m;

    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
        {
            if (i == j)
                Map[i][j] = 0;
            else
                Map[i][j] = INT_MAX;
        }//初始化图
    int a, b, c;
    while (m--)
    {
        scanf("%d%d%d", &a, &b, &c);
        Map[a][b] = min(Map[a][b], c);
        Map[a][b] = Map[b][a];
        //从b到a的距离等于从a到b的距离，写在这里，不然在上面写完后还需要再写一遍
    }//输入图

    for (int k = 1; k <= n; k++)
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                Map[i][j] = min(Map[i][j], Map[i][k] + Map[k][j]);
    //我们的Floyd-Warshall算法，详见下


    for (int i = 1; i <= n; i++) 
    {
        for (int j = 1; j <= n; j++) 
        {
            if (j == n) 
            {
                printf("%d", Map[i][j]);
            }
            else 
            {
                printf("%d ", Map[i][j]);
            }
        }
        printf("\n");//换行
    }


    return 0;
}

下面是思路（可能会错＞﹏＜）

Floyd-Warshall算法:

假设这是一个图，上面有4个节点ABCD，i 代表无穷大

   A  B  C  D
A  0  2  i  5
B  2  0  4  i
C  i  4  0  1
D  5  i  1  0

Floyd-Warshall 算法的初始循环会先按顺序选择一个节点作为中间节点

首先，我们选择 A 作为中间节点（k= A）：

1. 对于每一对节点 (B, C)，我们检查是否通过 A 可以找到更短的路径。直接路径是 4，而通过 A 的路径是 2 + 5 = 7。由于 4 不大于 7，我们更新路径为 4。

2. 对于每一对节点 (B, D)，我们检查是否通过 A 可以找到更短的路径。直接路径是无穷大，而通过 A 的路径是 2 + 5 = 7。由于无穷大于 7，我们更新路径为 7。

接下来，我们选择 B 作为中间节点（k = B）：

1. 对于每一对节点 (A, C)，我们检查是否通过 B 可以找到更短的路径。直接路径是无穷大，而通过 B 的路径是 2 + 4 = 6。由于无穷大于 6，我们更新路径为 6。

2. 对于每一对节点 (A, D)，我们检查是否通过 B 可以找到更短的路径。直接路径是 7，而通过 B 的路径是无穷大。由于 7 不大于无穷大，我们不更新路径。

最后，我们选择 C 作为中间节点（k = C）：

1. 对于每一对节点 (A, B)，我们检查是否通过 C 可以找到更短的路径。直接路径是 4，而通过 C 的路径是无穷大。由于 4 不大于无穷大，我们不更新路径。

2. 对于每一对节点 (A, D)，我们检查是否通过 C 可以找到更短的路径。直接路径是 7，而通过 C 的路径是 4 + 1 = 5。由于 7 不大于 5，我们更新路径为 5。

当然每个中间节点的例子没有举全，但看起来已经足够清晰明了

也就是说k会遍历所有点，所有的点都会被当做一次中间节点，并且此种算法考虑了所有可能的中间节点组合，因此不会遗漏任何可能的最短路径。回到题目，算法的每一轮都会选择一个节点 k 作为中间节点，并且会通过该中间节点来优化所有节点对 （i，j） 的路径。在完成所有的循环后，Map中存储的就是图中所有节点之间的最短路径。

再举一个小例子

假设现在有6个点，那我们从点2到点6怎么走路程最短呢，假设我们知道从点 2 到点 4 再到点 5 再到点 6 这样走路程最短，然后从点 2 直接到点 6 路程次之，其实最短的路线逻辑就是从点2再到中间节点 5 再到点 6，只不过在之前的遍历中已经储存了从点 2 到点 5 怎么走路程最短这一信息了。

当算法考虑中间节点5的时候，它已经计算并更新了从每个节点到节点 5 的最短路径。这样，当算法考虑到节点 6 的时候，它会利用已知的最短路径信息，包括从节点 2 到节点 5 的最短路径，以找到从节点 2 到节点 6 的最短路径。

for (int k = 1; k <= n; k++) 这一层循环在最前面，是为了确保我们考虑了所有可能的中间节点，从而找到所有节点对之间的最短路径。