图的多源汇最短路径——Floyd算法

题目描述

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

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

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

算法思想

Floyd算法是基于动态规划的思想，最开始只允许经过$1$号顶点进行中转，接下来只允许经过$1$和$2$号顶点进行中转，…，允许经过$1$~$n$号所有顶点进行中转，求任意两点之间的最短路程。

动态规划

状态表示

f[k, i, j]表示从i点出发，只经过$1$ ~ $k$这些点中转，到达j点的最短距离。

状态转移

f[k, i, j] = min (f[k, i, j], f[k - 1, i, k] + f[k - 1, k, j])

因为$k$阶段的状态只与$k-1$阶段的状态有关，可以进行优化：
f[i, j] = min(f[i, j], f[i, k] + f[k, j])

初始状态

f[i][i] = 0 表示从自己出发到达自己的距离为$0$。

代码

#include <iostream>
#include <cstring>
using namespace std;

const int N = 210, INF = 0x3f3f3f3f;

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

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

int main()
{
    cin >> n >> m >> k;

    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
            //存在自环，但不存在负权回路，所以将自环初始化为0，保证不被输入
            if(i == j) f[i][j] = 0; 
            else f[i][j] = INF;

    for(int i = 1; i <= m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        f[a][b] = min(f[a][b], c); //存在自环或重边
    }

    floyd();

    while(k--)
    {
        int a, b;
        cin >> a >> b;
        //因为存在负权边，虽然(a，b)之间不存在路径，但结果可能会比INF小一些
        if(f[a][b] >= INF / 2) puts("impossible");
        else cout << f[a][b] << endl;
    }
    return 0;
}