【刷题】图论——最短路：Floyd【证明+模板】

定义图有：n个点，m条边 。

这Floyd算法是处理多源最短路的算法，可以应对边权为负的情况，但不能处理负环。

时间复杂度是$O(n^3)$

算法步骤

• $for(k=1;k<=n;k++)$
  • $for(i=1;i<=n;i++)$
    • $for(j=1;j<=n;j++)$
      • $d[i,j]=min(d[i,j],d[i,k]+d[k,j])$

算法证明

floyd是基于动态规划的思路实现的。
$d[k,i,j]$表示从点$i$出发，只经过$1,2,...,k$的中间点，到达$j$的最短距离，设这条路径为$p$。

假设我们已经有了所有的$d[k-1,x,y]$，现在想要求$d[k,i,j]$。

1. 结点$k$不是$p$上的点，那么$p$只由$1,2,...,k-1$这些点组成，$d[k,i,j]=d[k-1,i,j]$
2. 结点$k$是$p$上的点，那么可以将路径分解为$i$ —$p_1$—> $k$ —$p_2$—> $j$
   因为$p_1$不含$k$，所以$p_1$的最短长度是$d[k-1,i,k]$。
   同理，$p_2$的最短长度是$d[k-1,k,j]$。
   $p_1$和$p_2$的最短长度相加就是最短总长度。

综上可以得到递推式：
$d[k,i,j]=d[k-1,i,k]+d[k-1,k,j]$

$d$的第一维$k$可以用滚动数组去掉，只用保留后两维。

由递推顺序，先知道k-1才能知道k，因此k循环放在最外面

算法实现

注意这题边权可能为负，哪怕不存在路径，dis[i]=INF也可能被更新，会比INF更小，不能直接判断dis[i] = INF，可以判断dis[i] > INF / 2输出impossible。

此外该题有自环，因为不存在负环，因此没有负自环，那么走自环肯定不如不走，要将dis[i][i]置为0。

#include 
using namespace std;

const int N = 205, M = 20005, INF = 0x3f3f3f3f;

int n, m, k;
int dis[N][N];

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

int main() {
    scanf("%d%d%d", &n, &m, &k);
    int u, v, w;
    for (int i = 1; i <= n; i ++ ) {
        for (int j = 1; j <= n; j ++ ) {
            if (i == j) dis[i][j] = 0; // 自环为0
            else dis[i][j] = INF;
        }
    }
    while (m --)  {
        scanf("%d%d%d", &u, &v, &w);
        dis[u][v] = min(w, dis[u][v]); // 重边留最小
    }
    floyd();
    while (k -- ) {
        scanf("%d%d", &u, &v);
        if (dis[u][v] > INF / 2) printf("impossible\n");
        else printf("%d\n", dis[u][v]);
    }
    return 0;
}