853. 有边数限制的最短路(Bellman_ford算法模板题)

853. 有边数限制的最短路 - AcWing题库

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出从 11 号点到 n号点的最多经过 k 条边的最短距离，如果无法从 11 号点走到 n 号点，输出 impossible。

注意：图中可能 存在负权回路 。

输入格式

第一行包含三个整数 n,m,k

接下来 m行，每行包含三个整数 x,y,表示存在一条从点 x 到点 y 的有向边，边长为 z。

点的编号为 1∼n1。

输出格式

输出一个整数，表示从 11 号点到 n 号点的最多经过 k 条边的最短距离。

如果不存在满足条件的路径，则输出 impossible。

数据范围

1≤n,k≤500
1≤m≤10000
1≤x,y≤n
任意边长的绝对值不超过 10000

输入样例：

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

输出样例：

3

解析：

这道题只能用贝尔曼福特算法 ，因为这道题他限制的边数k，要求经过的边数不超过k

bellman_ford算法存边没有要求，可以使用邻接表，也可以用结构体

基本思路：

n次迭代，每一次循环所有边(a,b,w,边a,b权重为w)，执行dist[a]=min(dist[b],dist[a]+w)

这个更新操作称为：松弛操作

循环结束后一定满足三角不等式：dist[a]<=dist[b]+w

此算法迭代k次的含义为，不超过k条边，到达某个点的最短距离

据此，我们可以知道，当第n次更新后的值与n-1次更新不同时，图中就有负环。

所以bellman_ford算法可以用来判断负环

时间复杂度为O(nm)

#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;
typedef pair<double, int > PDI;
typedef pair<int, int> PII;
const int N = 500 + 5, M = 10000 + 5, INF = 0x3f3f3f3f;

int n, m, k;
int dist[N], backup[N];
struct edge {
	int a, b, w;
}edge[M];

void bellman_ford() {
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	for (int i = 1; i <= k; i++) {
		memcpy(backup, dist, sizeof dist);
		for (int j = 1; j <= m; j++) {
			int a = edge[j].a, b = edge[j].b, w = edge[j].w;
			dist[b] = min(dist[b], backup[a] + w);
		}
	}

}

int main() {
	scanf("%d%d%d", &n, &m, &k);
	for (int i = 1; i <= m; i++) {
		scanf("%d%d%d", &edge[i].a, &edge[i].b, &edge[i].w);
	}
	bellman_ford();
	if (dist[n]>INF/2)cout << "impossible" << endl;
	else {
		cout << dist[n] << endl;
	}
	return 0;
}

需要注意的是，以 S 点为源点跑 Bellman–Ford 算法时，如果没有给出存在负环的结果，只能说明从 S 点出发不能抵达一个负环，而不能说明图上不存在负环。

因此如果需要判断整个图上是否存在负环，最严谨的做法是建立一个超级源点，向图上每个节点连一条权值为 0 的边，然后以超级源点为起点执行 Bellman–Ford 算法。