854. Floyd求最短路(Floyd算法，模板题)

854. Floyd求最短路 - AcWing题库

给定一个 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
图中涉及边长绝对值均不超过 1000010000。

输入样例：

3 3 2
1 2 1
2 3 2
1 3 1
2 1
1 3

输出样例：

impossible
1

解析：

Floyd算法基于动态规划：

设d[k,i,j]表示：经过若干个编号不超过k的节点，从i到j的最短路长度。

该问题可划分成两个子问题，经过编号不超过k-1的节点从i到j，或者从i先到k，再从k到j，于是：

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

初值d[0,i,j]=g[i,j],其中g为图的邻接矩阵。

可以看到，此算法的本质为动态规划。k是阶段，所以必须置于最外层循环中。

与背包问题类似，k这一维可以被省略。

Floyd算法可以处理负权，但不可以是负权回路。

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
#include<sstream>
#include<deque>
#include<unordered_map>
using namespace std;
const int N = 205, M = 1e4 + 5,INF =1e9;
int n, m, Q;
int d[N][N];

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

int main() {
	cin >> n >> m >> Q;
	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;
	for (int i = 1,a,b,c; i <= m; i++) {
		scanf("%d%d%d", &a, &b, &c);
		if(a!=b)
		d[a][b] = min(d[a][b], c);
	}
	floyd();
	for (int i = 1,a,b; i <= Q; i++) {
		scanf("%d%d", &a, &b);
		if (d[a][b] > INF / 2)printf("impossible\n");
		else printf("%d\n", d[a][b]);
	}
	return 0;
}