图算法--判负环

bellman-ford判负环，据bellman-ford的性质最后得出的是通过不超过n-1条边的从起点到其他点的最短距离（因为n个点，所以n-1条边）

但是如果在n-1次循环之后仍然存在边可以被松弛，那么就存在负环（因为如果没有负环n-1次就已经确定了最短距离，具体可参考bellman-ford证明，已经是最短距离了还能被松弛，必然是存在负环）

#include<iostream>
using namespace std;
const int N=2010,M=1e5+10;
int n,m;
struct edge{
    int a,b,w;
}edges[M];
int dis[N];
void bellman_ford(){
    //直接把dis初始化为全0就可以了，意思就是所有的点都是起点
    for(int i=0;i<n-1;i++){
        for(int j=0;j<m;j++){
            auto t=edges[j];
            if(dis[t.b]>dis[t.a]+t.w){
                dis[t.b]=dis[t.a]+t.w;
            }
        }
    }
}
int main(void){
    cin>>n>>m;
    for(int i=0;i<m;i++){
        int a,b,c;
        cin>>a>>b>>c;
        edges[i]={a,b,c};
    }
    bellman_ford();
    for(int j=0;j<m;j++){
            auto t=edges[j];
            if(dis[t.b]>dis[t.a]+t.w){
                cout<<"Yes";
                return 0;
            }
    }
    cout<<"No";
    return 0;
}

spfa判负环

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
const int N=2010,M=1e5+10;
int n,m;
int h[N],e[M],w[M],ne[M],idx;
int dis[N],cnt[N];
bool st[N];
void add(int a,int b,int c){
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
bool spfa(){
    queue<int> q;
    for(int i=1;i<=n;i++){
        q.push(i);
        st[i]=true;
    }//把所有的点都丢进队列里面
    while(q.size()){
        int t=q.front();
        q.pop();
        st[t]=false;
        for(int i=h[t];i!=-1;i=ne[i]){
            int j=e[i];
            if(dis[j]>dis[t]+w[i]){
                dis[j]=dis[t]+w[i];
                cnt[j]=cnt[t]+1;
                if(cnt[j]>=n){
                    return true;
                }
                if(!st[j]){
                    q.push(j);
                    st[j]=true;
                }
            }
        }
    }
    return false;
}
int main(void){
    cin>>n>>m;
    memset(h,-1,sizeof(h));
    for(int i=0;i<m;i++){
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    if(spfa()){
        cout<<"Yes";
    }else{
        cout<<"No";
    }
    return 0;
}