使用spfa算法判断有没有负环

如果存在最短路径的边数大于等于点数，就有负环

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

请你判断图中是否存在负权回路。

输入格式

第一行包含整数n和m。

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

输出格式

如果图中存在负权回路，则输出“Yes”，否则输出“No”。

数据范围

1≤n≤20001≤n≤2000,
1≤m≤100001≤m≤10000,
图中涉及边长绝对值均不超过10000。

输入样例：

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

输出样例：

Yes


###########################################

#include <bits/stdc++.h>
using namespace std;
//优化的贝尔曼福特算法，就是spfa算法，用更新过的点去更新和它相连接的点
const int N = 2010, M = 10010;
int h[N], e[M], w[M], ne[M];
int idx;
int dist[N], cnt[N];
bool flag[N];//代表该节点当前是否在队列里
int n, m;

void add(int a, int b, int c){
    w[idx] = c; e[idx] = b;       
    ne[idx] = h[a];
    h[a] = idx ++;
}

bool spfa(){
    queue<int> q;//队列中存储的是已经更新过用来更新其他节点的点
    //所有的点都是起点,加入队列
    for(int i = 1;i <= n;++i){
        q.push(i);
        flag[i] = true;
    }
    while(!q.empty()){
        int t = q.front(); q.pop();
        flag[t] = false;//移除队列里
        for(int i = h[t];i != -1;i = ne[i]){
            int j = e[i];
            //更新成功
            if(dist[j] > dist[t] + w[i]){
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;//更新边数
                if(cnt[j] >= n)return true;
                if(!flag[j]) {//如果j不在队列里
                    q.push(j);
                    flag[j] = true;//放进队列里
                }
            }
        }
    }
    return false;
}

int main(){
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof h);
    while(m--){
        int x, y, z;
        scanf("%d%d%d", &x, &y, &z);
        add(x, y, z);
    }
    if (spfa()) puts("Yes");
    else puts("No");
}