57、【图】Floyd算法求最短路径（多源最短路径）（C/C++版）

算法介绍

Floyd算法用来解决多源最短路径，即可得到图中任意两个结点之间的最短路径。

该算法基于动态规划的思想。假设有n个节点，目标是求节点i到达节点j的最短路径。

每次求的时候，都将节点i到节点j经过k个节点到达最短路径状态记录下来，即d[k][i][j]，意为在状态k下，从节点i经过编号为1、2…k到节点j时路径最短。

当要找下一个节点的最短路径时，使用之前已经记录的状态进行对比，可得到新的状态转移方程

便可以此状态转移方式，遍历所有点之间的情况构造最短路径算法。

题目描述

给定一个 n 个点 m条边的有向图，图中可能存在重边和自环，边权可能为负数。

再给定 k个询问，每个询问包含两个整数 x 和 y，表示查询从点 x 到点 y的最短距离，如果路径不存在，则输出 impossible。

数据保证图中不存在负权回路。

输入格式

一行包含三个整数 n,m,k。
接下来 m行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
接下来 k行，每行包含两个整数 x,y，表示询问点 x 到点 y的最短距离。

输出格式

共 k行，每行输出一个整数，表示询问的结果，若询问两点间不存在路径，则输出 impossible。

数据范围

1≤n≤200,
1≤k≤n2
1≤m≤20000,
图中涉及边长绝对值均不超过 10000。

输入样例：

3 3 2
1 2 1
2 3 2
1 3 1
2 1
1 3

输出样例：

impossible
1

题目分析

算法的核心是对所有点的遍历部分，使用三层for循环进行实现。

for(k)			// k为中转点，起始点为1
	for(i)		// i为起始点，起始点为1
		for(j)	// j为目标点，起始点为1
			d[i][j] = min(d[i][j], d[i][k] + d[k][j])

在这里有一个重要的地方，三层for循环的结构虽然简单，但每层for循环的含义必须要按顺序设计，否则将会得到错误的答案。Floyd算法在代码实现上虽然简单但并不是很多人都真正的懂这个算法，原因就在于对于for循环的理解。

这里有两个很赞的答案：

（1）从数学角度

（2）从程序设计角度

参考资料：
Floyd算法为什么把k放在最外层

为什么Floyd算法中k必须放在最外层

算法实现

#include <stdio.h>

const int N = 210, INF = 1e9;       //由于题中权重不超过1e4，因此取INF为1e9（2倍的指数再多一位）
int d[N][N];    // 邻接矩阵

int min(int a, int b)   {   return a < b ? a : b;   }

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++)
                    d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}

int main(){
    int n, m, q;        scanf("%d%d%d", &n, &m, &q);
    int x, y, z;        // 一对点和权重
    // 初始化邻接矩阵为无穷大
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
           if(i != j)   d[i][j] = INF;
    
    // 获取权重最小的那条边
    while(m--){
        scanf("%d%d%d", &x, &y, &z);
        d[x][y] = min(d[x][y], z);
    }
    floyd(n);
    
    // 查询q对最短路径
    while(q--){
        scanf("%d%d", &x, &y);
        if(d[x][y] > INF / 2)       // 若不存在路径则输出impossible
            puts("impossible");
        else
            printf("%d\n", d[x][y]);
    }
    
    return 0;
}

无注释代码

#include <stdio.h>

const int N = 210, INF = 1e9;

int min(int a, int b)   {   return a < b ? a : b;    }

void floyd(int n, int d[][N]){
    for(int k = 1; k <= n; k++)
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}

int main(){
    int n, m, q;        
    int x, y, z;
    int d[N][N];
    scanf("%d%d%d", &n, &m, &q);
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
            if(i != j)  d[i][j] = INF;
            
    while(m--){
        scanf("%d%d%d", &x, &y, &z);
        if(d[x][y] > z)     d[x][y] = z;
    }
    floyd(n, d);
    
    while(q--){
        scanf("%d%d", &x, &y);
        if(d[x][y] > INF / 2)       puts("impossible");
        else    printf("%d\n", d[x][y]);
    }
    
    return 0;
}

时间复杂度为O(n³)