题目链接

负环

题目描述

给定一个 $n$ 个点的有向图，请求出图中是否存在从顶点 $1$ 出发能到达的负环。

负环的定义是：一条边权之和为负数的回路。

输入格式

本题单测试点有多组测试数据。

输入的第一行是一个整数 $T$，表示测试数据的组数。对于每组数据的格式如下：

第一行有两个整数，分别表示图的点数 $n$ 和接下来给出边信息的条数 $m$。

接下来 $m$ 行，每行三个整数 $u,v,w$。

• 若 $w\ge 0$，则表示存在一条从 $u$ 至 $v$ 边权为 $w$ 的边，还存在一条从 $v$ 至 $u$ 边权为 $w$ 的边。
• 若 $w<0$，则只表示存在一条从 $u$ 至 $v$ 边权为 $w$ 的边。

输出格式

对于每组数据，输出一行一个字符串，若所求负环存在，则输出 YES，否则输出 NO。

样例 #1

样例输入 #1

2
3 4
1 2 2
1 3 4
2 3 1
3 1 -3
3 3
1 2 3
2 3 4
3 1 -8

样例输出 #1

NO
YES

提示

数据规模与约定

对于全部的测试点，保证：

• $1\le n\le 2\times 10^3$，$1\le m\le 3\times 10^3$。
• $1\le u,v\le n$，$-10^4\le w\le 10^4$。
• $1\le T\le 10$。

提示

请注意，$m$ 不是图的边数。

算法思想

判断图中是否存在负环，需要先了解下面关于最短路的几个性质：

• 对于边权为正的图，任意两个节点之间的最短路，不会经过重复的节点。
• 对于边权为正的图，任意两个节点之间的最短路，不会经过重复的边。
• 对于边权为正的图，任意两个节点之间的最短路，任意一条的节点数不会超过$n$，边数不会超过 $n-1$。

Bellman–Ford 算法

Bellman–Ford 算法是一种基于松弛（relax）操作的最短路算法，可以求出有负权的图的最短路，并可以对最短路不存在的情况进行判断。大名鼎鼎的「SPFA」，就是 Bellman–Ford算法的一种实现。

基本思想

Bellman–Ford算法所做的，就是不断尝试对图上每一条边进行松弛。每进行一轮循环，就对图上所有的边都尝试进行一次松弛操作，当一次循环中没有成功的松弛操作时，算法停止。

对于边 $(u,v)$，Bellman–Ford算法中松弛操作对应下面的式子：$dis(v)=\min (dis(v),dis(u)+w(u,v))$。尝试用 $S\to u\to v$（其中 $S\to u$ 的路径取最短路）这条路径去更新 $v$ 点最短路的长度，如果这条路径更优，就进行更新。

每次循环的时间复杂度是$O(m)$，那么最多会循环多少次呢？

在最短路存在的情况下，由于一次松弛操作会使最短路的边数至少 $+1$，而最短路的边数最多为 $n-1$，因此整个算法最多执行 $n-1$ 轮松弛操作。故总时间复杂度为 $O(nm)$。

但还有一种情况，如果从 $S$ 点出发，抵达一个负环时，松弛操作会无休止地进行下去。对于最短路存在的图，松弛操作最多只会执行 $n-1$ 轮，因此如果第 $n$ 轮循环时仍然存在能松弛的边，说明从 $S$ 点出发，能够抵达一个负环。

代码实现

struct Edge {int u, v, w;
};vector<Edge> edge;int dis[MAXN], u, v, w;
const int INF = 0x3f3f3f3f;
//节点数n，起点s
bool bellmanford(int n, int s) {memset(dis, 0x3f, sizeof(dis));dis[s] = 0;bool flag = false;  // 判断一轮循环过程中是否发生松弛操作for (int i = 1; i <= n; i++) {flag = false;for (int j = 0; j < edge.size(); j++) {u = edge[j].u, v = edge[j].v, w = edge[j].w;if (dis[u] == INF) continue;// 无穷大与常数加减仍然为无穷大// 因此最短路长度为 INF 的点引出的边不可能发生松弛操作if (dis[v] > dis[u] + w) {dis[v] = dis[u] + w;flag = true;}}// 没有可以松弛的边时就停止算法if (!flag) {break;}}// 第 n 轮循环仍然可以松弛时说明 s 点可以抵达一个负环return flag;
}

队列优化的Bellman–Ford

SPFA即 Shortest Path Faster Algorithm，即队列优化的Bellman–Ford。很多时候Bellman–Ford算法并不需要那么多无用的松弛操作， 只有上一次被松弛的结点，所连接的边，才有可能引起下一次的松弛操作。那么可以用队列来维护哪些结点可能会引起松弛操作，就能只访问必要的边了。

SPFA也可以用于判断$s$点是否能抵达一个负环，只需记录最短路经过了多少条边，当经过了至少$n$条边时，说明$s$点可以抵达一个负环。

代码实现

struct edge {int v, w;
};vector<edge> e[maxn];
int dis[maxn], cnt[maxn], vis[maxn];
queue<int> q;bool spfa(int n, int s) {memset(dis, 0x3f, sizeof(dis));dis[s] = 0, vis[s] = 1;q.push(s);while (!q.empty()) {int u = q.front();q.pop(), vis[u] = 0;for (auto ed : e[u]) {int v = ed.v, w = ed.w;if (dis[v] > dis[u] + w) {dis[v] = dis[u] + w;cnt[v] = cnt[u] + 1;  // 记录最短路经过的边数if (cnt[v] >= n) return false;// 在不经过负环的情况下，最短路至多经过 n - 1 条边// 因此如果经过了多于 n 条边，一定说明经过了负环if (!vis[v]) q.push(v), vis[v] = 1;}}}return true;
}

虽然在大多数情况下SPFA跑得很快，但其最坏情况下的时间复杂度为 $O(nm)$，将其卡到这个复杂度也是不难的，所以考试时要谨慎使用。在没有负权边时最好使用Dijkstra算法，在有负权边且题目中的图没有特殊性质时，若SPFA是标算的一部分，题目不应当给出Bellman–Ford算法无法通过的数据范围。