Floyd算法模板

题目如下：

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

模板如下：
 

#include <iostream>
#include <vector>
#include <climits>
using namespace std;

const int INF = INT_MAX / 2;
const int N = 210;
vector<vector<int>> dist(N, vector<int>(N, INF));
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++) {
                if (dist[i][k] != INF && dist[k][j] != INF && dist[i][k] + dist[k][j] < dist[i][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                }
            }
        }
    }
}

int main(){
    cin >> n >> m >> k;
    for(int i = 1; i <= m; i++){
        int x, y, z;
        cin >> x >> y >> z;
        dist[x][y] = min(dist[x][y], z);
    }
    
    for(int i = 1; i <= n; i++){
        dist[i][i] = 0;
    }
    
    floyd();
    
    while(k--){
        int f, t;
        cin >> f >> t;
        if(dist[f][t] == INF){
            cout << "impossible" << endl;
        }else{
            cout << dist[f][t] << endl;
        }
    }
    
    return 0;
}