【图论】Day03_最短路算法之「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≤2001≤n≤200,
  1≤k≤n21≤k≤n2
  1≤m≤200001≤m≤20000,
  图中涉及边长绝对值均不超过10000。

输入样例：
3 3 2
1 2 1
2 3 2
1 3 1
2 1
1 3
输出样例：
impossible
1

二、什么是 Floyd 算法 ？

• 多源最短路算法，复杂度最高 $O(n^3)$，通常用在点比较少且起点不固定的问题中。
• 能解决存在负边但不能解决负环图最短路问题。

算法思想

从一个点 i 到另一个点 j，无非就两种走法：

• 直接从 i 到 j
• 通过中间点 k 中转，i—>k—>j

Floyd 算法就是遍历所有情况，如果通过某个中转点 k 的距离小于直接到达距离，就更新这两点间的距离为中转距离。

需要注意的问题：

• Q1：如果解决重边和自环？
  A1：如果有自环，那么临界矩阵一定是 $(i, i)$ 这些位置，所以只要让这些位置的值置为 0，即代表自己到自己的距离为 0。
• Q2：如何解决重边？
  A2：这个好办，当有新的赋值时，取 min(新值，旧值) 即可。

import java.util.*;
import java.math.*;
import java.io.*;
public class Main{
	static int V, E, k;
	static int[][] dp;
	static int INF = 0x3f3f3f3f;
	
	static void floyd() {
		for (int k = 1; k <= V; k++)
		for (int i = 1; i <= V; i++)
		for (int j = 1; j <= V; j++) {
			dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k][j]);
		}
	}
	
    public static void main(String[] args) throws IOException {  
        Scanner sc = new Scanner(new BufferedInputStream(System.in));
        BufferedWriter w = new BufferedWriter(new OutputStreamWriter(System.out));
        
		V = sc.nextInt();
		E = sc.nextInt();
		k = sc.nextInt();
		dp = new int[V+1][V+1];
		
		for (int i = 1; i <= V; i++)
		for (int j = 1; j <= V; j++) {
			if (i == j)					//防止自环
				dp[i][j] = 0;
			else
				dp[i][j] = INF;
		}
		for (int i = 0; i < E; i++) {
			int a = sc.nextInt();
			int b = sc.nextInt();
			int c = sc.nextInt();
			dp[a][b] = Math.min(dp[a][b], c);	//解决重边问题
		}
		
		floyd();
		
		for (int i = 0; i < k; i++) {
			int x = sc.nextInt();
			int y = sc.nextInt();
			if (dp[x][y] > INF / 2)
				System.out.println("impossible");
			else 
				System.out.print(dp[x][y]);
		}
    }
}

复杂度分析

• 时间复杂度： $O(V^3)$，
• 空间复杂度： $O(V^3)$，