最短路径模板——Floyd算法

Floyd算法

基于动态规划的思想实现：
f[i, j, k]表示从 i 走到 j 的路径上除起点 i 和 终点 j 外只经过 1 到 k号点之间的点的所有路径的最短距离。

这中间可能经过一个点，也可能经过多个点，也可能不经过其中任何一个点。

有动态转移方程：f[i, j, k] = min(f[i, j, k - 1), f[i, k, k - 1] + f[k, j, k - 1]

采用 邻接矩阵f 存储，初始化存储的边的信息就是f[i,j,0]的状态，就是i->j是直达的，其中不经过任何顶点。

求f[i,j,1]时就是判断i->j的路径需不需要经过顶点1，有两种选择，选或者不选；
求f[i,j,2]时就是判断i->j的路径需不需要经过顶点1、2，这时f[i,j,1]已经求出了需不需要经过顶点1下的最短路径，可以在此基础上只判断需不需要经过顶点2即可。

在计算第k层的f[i, j]的时候必须先将第k - 1层的所有状态计算出来，即每判断是否经过一个顶点就更新一次邻接矩阵二维数组f，共更新n次。
且可以证明本次更新的f[i，j]不会在本次中用到，因为每次会被用到的是f[i，k]和f[k，j]，除非k=j，或者k=i，但是f[i,i]=0，相当于没有加，所以不用再开一个数组来维护更新前和更新后的数据。

一、这就涉及到一个问题，Floy的算法必须要处理的地方：自环
Floyd算法不能处理带负环的图（自环权值为负时也是负环），而且当自环权值为正数时，也不行，必须规定邻接矩阵中主对角线(自身到自身)的距离为0。

考虑第一次k=1的更新情况，假如更新f[1,3]，f[1,3]=f[1,1]+f[1,3]，会出现这样的更新情况，因此必须规定自身到自身的距离为0，
这也是邻接矩阵存图的定义，当数据输入自环的边时(由于不存在负权回路，所以不会输入自环权值为负的边，只会是正数)，所以可以取边的最小值来处理这种情况。(重边的处理)
朴素dijkstra算法中用邻接矩阵存储时，权值为正的自环就不用处理，因为它没影响，仔细分析缘由。

二、重边的处理

由于是邻接矩阵存储图，只能存储一条边，所以只存权值最小的边。(存在负权边)
且主对角线一定要是0。

注意一个问题，由于题目要求了不存在负权回路，所以自环的边肯定也是正数，所以可以和普通的边一样，统一处理：
先将主对角线初始化为0，然后取最小值(每次取的一定是0)

三、可达性的判断

f[i，j]=min(f[i，j]，f[i，k]+f[k，j])，可以更新的情况是 i到 k 可达，且 k 到 j 也可达才行，只要有一条边不可达，是INF，就不用更新了，肯定是f[i，j]=f[i，j]
判断条件：if (f[i][k]!=INF && f[k][j]!=INF)

这样就不用担心负权边对INF的影响了，虽然不可达，但距离不是INF，比INF略小的问题。

题目描述

给定一个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≤n²
1≤m≤20000,
图中涉及边长绝对值均不超过10000。

输入样例：

3 3 2
1 2 1 //输入m条边
2 3 2
1 3 1
2 1 //接下来是k次查询
1 3

输出样例：

impossible
1

代码实现

#include <iostream>
#include <cstring>

using namespace std;
const int N=210,INF=0x3f3f3f3f;
int dp[N][N];
int n,m,num;

void floyd()
{
    for (int k=1;k<=n;k++)  更新n次dp二维表，求出i->j在最多经过n个顶点的下的最短路径
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                if (dp[i][k]!=INF && dp[k][j]!=INF) dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]);
}

int main()
{
    scanf("%d%d%d",&n,&m,&num);
    
    memset(dp,0x3f,sizeof dp);
    for (int i=0;i<=n;i++) dp[i][i]=0; //结点编号从1到n，0行0列用不到
    int a,b,c;
    while(m--) {
        scanf("%d%d%d",&a,&b,&c);
        dp[a][b]=min(dp[a][b],c); //处理重边，自环时c必大于0，所以主对角线还是0
    }
    floyd(); 
    //然后dp数组存储任意两个点之间的最短距离
    while(num--) {
        scanf("%d%d",&a,&b);
        int t=dp[a][b];
        if (t==INF) puts("impossible");
        else printf("%d\n",t);
    }
    
    return 0;
}