SPFA判负环

两种方式：

DFS：若一个点在用dfs这样的方式跑最短路的时，在同一路径出现多次那么可判断有负环。

注意由于我们主要是判断有无负环，所以可简化最短路的算法，即dis数组初始化为0，只跑负权边即可。

//dfs-SPFA判负环
//参考了洛谷的模板题面，但由于数据太强，所以过不去 
//复杂度比较玄学 
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

const int N = 2010, M = 3010;
struct edge {
	int v, w, next;
} e[M<<1];
int T, n, m;
int cnt, head[N];
int dis[N];
bool flag, vis[N];

void init() {
	memset(head, -1, sizeof(head));
	memset(dis, 0, sizeof(dis));
	memset(vis, false, sizeof(vis));
	memset(e, 0, sizeof(e));
	cnt = 0;
	flag = false;
	return ;
}

void add(int a, int b, int c) {
	e[++cnt].v = b;
	e[cnt].w = c;
	e[cnt].next = head[a];
	head[a] = cnt;
}

void spfa(int u) {
	int i;
	vis[u] = true;
	for (i = head[u]; i+1; i = e[i].next) {
		int v = e[i].v, w = e[i].w;
		if (dis[v] > dis[u]+w) {
			dis[v] = dis[u]+w;
			if (vis[v]) {
				flag = true;
				return ;
			}
			else {
				spfa(v);
				if (flag) return ;
			}
		}
	}
	vis[u] = false;
	return ;
}

int main() {
	scanf("%d", &T);
	while (T--) {
		init();
		scanf("%d%d", &n, &m);
		int i, a, b, c;
		for (i = 1; i <= m; i++) {
			scanf("%d%d%d", &a, &b, &c);
			add(a, b, c);
			if (c >= 0) add(b, a, c);	
		}
		for (i = 1; i <= n; i++) {
			if (flag) break;
			else if (!vis[i]) spfa(i);
		}
		if (!flag) printf("N0\n");
		else printf("YE5\n");
	}
	return 0;
}

BFS：因为图的任意一条最短路径既不能包含负权回路，也不会包含正权回路，因此它最多包含n-1条边。

又因为SPFA是根据边来松弛，那么对于一个点，最多松弛n-1次，所以只需统计一个点在队列中的出现次数即可。若大于n-1，有负环，否则，则没有。另外就是关于为什么要统计入队次数，而不是松弛的次数，这其实也很简单，因为对于一个点的每一次比较大小，并不是只要满足了小于关系就可以算是松弛了，因为在距离它下次出队的这一段时间里还有可能有更优的边，而这更优的边显然会取代它，说通俗点就是谁坚持到最后谁就是本次的松弛了（最多有n-1次，以出队隔开）。

再补充一点：一个点从入队到出队之间所有能够使dis[该点]变小的操作可以称之为松弛，每一次大的松弛（指使那个点入队的松弛）都会找到目标点和源点最短路径中的一条边。

SPFA是基于Bellman Ford的，所以若对上面我所说的有疑问的话，可以看一下Bellman Ford算法的描述性证明：

https://baike.baidu.com/item/Bellman-Ford%E7%AE%97%E6%B3%95/1089090?fr=aladdin

//bfs判负环-----O(MN)
//参考了洛谷题面，但具体点的话不是相同的一道题 
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;

const int N = 2010, M = 3010, INF = 0x3f3f3f3f;
struct edge {
	int v, w, next;
} e[M<<1];
queue<int> Q;
int n, m;
int cnt, head[N];
int dis[N], num[N];
bool vis[N];

void init() {
	memset(head, -1, sizeof(head));
	memset(dis, INF, sizeof(dis));
	return ;
}

void add(int a, int b, int c) {
	e[++cnt].v = b;
	e[cnt].w = c;
	e[cnt].next = head[a];
	head[a] = cnt;
	return ;
}

bool spfa(int u) {
	int i;
	Q.push(u);
	dis[u] = 0;
	vis[u] = true;
	while (!Q.empty()) {
		int p = Q.front();
		Q.pop();
		vis[p] = false;
		for (i = head[p]; i+1; i = e[i].next) {
			int v = e[i].v, w = e[i].w;
			if (dis[v] > dis[p]+w) {
				dis[v] = dis[p]+w;
				if (!vis[v]) {
					num[v]++;
					if (num[v] > n-1) return true;
					Q.push(v);
					vis[v] = true;
				}
			}
		}
	}
	return false;
}

int main() {
	init();
	scanf("%d%d", &n, &m);
	int i, a, b, c;
	for (i = 1; i <= m; i++) {
		scanf("%d%d%d", &a, &b, &c);
		add(a, b, c);
		if (c >= 0) add(b, a, c);	
	}
	if (spfa(1)) printf("YES\n");
	else printf("N0\n");
	return 0;
}