题目描述
给定一个 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

import java.util.*;
import java.io.*;

class Main {

    static final BufferedReader cin = new BufferedReader(new InputStreamReader(System.in));
    static final int N = 210, INF = (int)1e9;
    static int[][] d = new int[N][N];
    static int n, m, k;

    public static void folyd() {
        for (int k = 1; k <= n; k ++) 
            for (int i = 1; i <= n; i ++) 
                for (int j = 1; j <= n; j ++) 
                    if (d[i][k] != INF && d[k][j] != INF)  //中间路径不能够是走不通的
                        d[i][j] = Math.min(d[i][j], d[i][k] + d[k][j]);
    }

    public static void main(String[] args) throws Exception{
        String[] ss = cin.readLine().split(" ");
        n = Integer.parseInt(ss[0]);
        m = Integer.parseInt(ss[1]);
        k = Integer.parseInt(ss[2]);
        //初始化
        for (int i = 1; i <= n; i ++) {
            for (int j = 1; j <= n; j ++) {
                if (i == j) d[i][j] = 0;
                else d[i][j] = INF;
            }
        }

        //读取所有的边
        while (m -- != 0) {
            ss = cin.readLine().split(" ");
            int a = Integer.parseInt(ss[0]), b = Integer.parseInt(ss[1]), w = Integer.parseInt(ss[2]);
            //赋值最小的边权重
            d[a][b] = Math.min(w, d[a][b]);
        }

        //folyd算法
        folyd();

        //处理查询
        while (k -- != 0) {
            ss = cin.readLine().split(" ");
            int a = Integer.parseInt(ss[0]), b = Integer.parseInt(ss[1]);
            if (d[a][b] == INF) System.out.println("impossible");
            else System.out.println(d[a][b]);
        }
    }

}