图论 —— 最短路 —— Floyd 算法

【概述】 

Floyd 算法又称为插点法，是一种用于寻找给定的加权图中多源点之间最短路径的算法。

其最大特点是可以计算出现负边权时的最短路，实际应用中，很多题目不是问如何用 Floyd 求最短路，而是用 Floyd 的动态规划思想来解决类似 Floyd 的问题。

其时间复杂度是 O(N*N*N)，N是顶点数。

【极大值的选择】

设置无穷大时，0x7fffffff 是 32-bit int 的最大值，如果这个无穷大只用于一般的比较，那么 0x7fffffff 是一个完美的选择，但在更多情况下，其并不是一个好的选择。

在最短路的松弛操作时，如果 u、v 间无边，那么 w[u][v]=INF，此时若 INF 取 0x7fffffff，那么 dis[u]+w[u][v] 会溢出而变成负数，此时松弛操作便会出错，准确来说，0x7fffffff 不能满足无穷大加一个有穷的数依然是无穷大，而是变成了一个很小的负数。

if(dis[u]+w[u][v]<dis[v]) 
    dis[v]=dis[u]+w[u][v];

由于要找一个能够满足无穷大加无穷大依然是无穷大的数，因此，可以选用 0x3f3f3f3f

0x3f3f3f3f 的十进制是 1061109567，是 10^9 级别的，与 0x7fffffff 一个数量级，而一般场合下的数据都是小于10^9的，所以它可以作为无穷大使用而不致出现数据大于无穷大的情形。 

另一方面，由于一般的数据都不会大于 10^9，所以当我们把无穷大加上一个数据时，它并不会溢出，事实上 0x3f3f3f3f + 0x3f3f3f3f = 2122219134，这个数虽然非常大但却没有超过 32-bit int 的表示范围，因此 0x3f3f3f3f 还满足了无穷大加无穷大还是无穷大的需求。

此外，当想将某个数组清零或全部赋值为 -1，通常会使用 memset() 函数，但是当想将某个数组全部赋值为无穷大时，就不能使用memset 函数而是写循环了，因为 memset 是按字节操作的，它能够对数组清零是因为 0 的每个字节都是 0。但如果将无穷大设为 0x3f3f3f3f，由于其每个字节都是 0x3f，因此可以直接使用 memset() 函数来操作。

【算法核心】

1.初始化：

设 dis[i][j] 为 i、j 两点的距离，w[i][j] 为 i、j 两点的权值。

若点 u、v 有边连接，则：dis[u][v]=w[u][v]，即：初始化两点最短距离为两点权值。

若点 u、v 无边连接，则：dis[u][v]=0x3f3f3f3f，即：初始化为一极大值。

2.算法主体

for(int k=1;k<=n;k++)//第一重循环为i→j的中间点k
    for(int i=1;i<=n;i++)//第二重循环为起点i
        for(int j=1;j<=n;j++)//第三重循环为终点j
            if(dis[i][j]>dis[i][k]+dis[k][j])//如果i→k的距离加上k→j的距离小于i→j的距离
                dis[i][j]=dis[i][k]+dis[k][j];//更新最短路径

3.算法结束：dis[i][j] 即为 i→j 的最短路径。

【模版】

int G[N][N];
int path[N][N];//path[i][j]=x表示i到j的路径上除i外的第一个点是x
void init(int n) {
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (i == j)
                G[i][j] = 0;
            else
                G[i][j] = INF;
            path[i][j] = j;
        }
    }
}
void floyd(int n) {
    for (int k = 1; k <= n; k++) {         //枚举中间点
        for (int i = 1; i <= n; i++) {     //枚举起点
            for (int j = 1; j <= n; j++) { //枚举终点
                if (G[i][k] < INF && G[k][j] < INF) {
                    if (G[i][j] > G[i][k] + G[k][j]) { //松弛操作
                        G[i][j] = G[i][k] + G[k][j];
                        path[i][j] = path[i][k]; //更新路径
                    } 
                    else if (
                        G[i][j] == G[i][k] + G[k][j] && path[i][j] > path[i][k]) { //在最短路相同的情况下，更新字典序最小的路径
                        path[i][j] = path[i][k]; //最终path中存的是字典序最小的路径
                    }
                }
            }
        }
    }
}
int main() {
    int n, m;
    while (scanf("%d%d", &n, &m) != EOF) {
        init(n);
        for (int i = 1; i <= m; i++) {
            int x, y, dis;
            scanf("%d%d%d", &x, &y, &dis);
            //无向图添边一次,有向图添边两次
            G[x][y] = dis;
            G[y][x] = dis;
        }

        floyd(n);

        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++)
                printf("%d ", G[i][j]);
            printf("\n");
        }
    }
    return 0;
}