AcWing 854. Floyd求最短路(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。

输入输出样例 ：

输入

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

输出

impossible
1

题目分析：

Floyd算法主要用于解决多源汇最短路问题，且图中不能存在负权回路。Floyd算法是基于动态规划的算法思想，每一次通过松弛操作更新最短路时，都是基于上一个状态。Floyd算法核心代码只有短短的四行代码，其代码如下：

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]);
}

d[i][j]记录的是从点i到点j的最短路，要想得到最短路，就要不断进行松弛操作。关于松弛操作，就是判断让v1、v2通过一个中间点，这样走的所有边的权重和是否比原有的边权更小，若更小则进行替换。比如要从1点到3点，通过点2进行松弛，代码为

d[1][3] = min(d[1][3], d[1][2]+d[2][3]);

要想将图中任意两点都通过2点进行松弛操作则要

for （int i = 1; i <= n; i ++ ）
  for (int j = 1; j <= n; j ++ )
    d[i][j] = min(d[i][j], d[i][2] + d[2][j]; 

进一步，要想图中任何两点之间通过图中所有点进行松弛操作，最后d中储存的就是图中任何两个点之间的最短距离。这就是 ：

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]);
}

总结来说，每一次循环都是求，从i点到j点只经过前k个点的最短路程。这就是Floyd算法，本题的具体做法详见代码。

代码 ：

#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 210, INF = 1e9;//INF表示无穷大 
int n, m, q;//n个点，m条边，q次询问 
int d[N][N];//d[i][j]记录从点i到点j的最短距离 
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;
	}
	while (m -- ) {
		int v1, v2, w;
		cin >> v1 >> v2 >> w;
		d[v1][v2] = min(d[v1][v2], w);//初始化
	}
	floyd();
	while (q -- ) {
		int v1, v2;
		cin >> v1 >> v2;
		if (d[v1][v2] > INF / 2) cout << "impossible" << endl;
		else cout << d[v1][v2] << endl; 
	}
	return  0;
}

---

下面我们给出Floyd算法模板

时间复杂度是 O(n^3), n表示点数

初始化：
    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;

// 算法结束后，d[a][b]表示a到b的最短距离
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]);
}