spfa判断负环

在上篇博客中我提到spfa算法求最短路的方法，需要注意到的是，如果一个图中存在负环，则两点之间路径上带有负环的点是不可能存在最小路径的，也就是说这两点之间的最小距离会被一直更新，如果更新的次数大于等于n不就说明图中存在负环了吗？

因为本质上spfa算法是对sellman_ford算法的优化，而bellman-ford算法遍历k次求出的是从源点经过不超过k条边走到任一点的最短距离，若两点之间的距离在第n-1次更新后还能更新，不就说明两点之间存在超过n-1条边的最短路了么，那不就是说说存在负环吗。

所以我们在spfa算法求最短路的问题上加一个cnt[]数组用于记录每个点到源点的距离被更新的次数，当某点到源点的距离被更新的次数大于等于n时就说明存在负环。

核心代码：

bool spfa()
{
//    memset(dist,0x3f,sizeof dist);由于我们只要记录每个点被更新的次数，所以dist[]的初始值对判断负环不参生影响 
    for(int i=1;i<=n;i++)//由于负环不一定是到源点的路径上产生的，所以要把所有点入队列 
    {
        q.push(i);
        vis[i]=true;
    }
    while(q.size())
    {
        int t=q.front();
        q.pop();
        vis[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;//源点到j的最短路径所含的边数等于源点到t的最短路径所含的边数+1 
                if(cnt[j]>=n) return true;//如果源点到j的最短路径所含的边数大于等于n，说明有负环 
                if(!vis[j])
                {
                    q.push(j);
                    vis[j]=true;
                }
            }
        }
    }
    return false;
}

下面给出一道例题：

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

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

输入格式

第一行包含整数 n 和 m。

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

输出格式

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

数据范围

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

输入样例：

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

输出样例：

Yes

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream> 
#include<queue>
using namespace std;
const int N=10002;
int e[N],h[N],w[N],ne[N],idx,dist[N],cnt[N];
bool vis[N];
queue<int>q;
int n,m;

void add(int x,int y,int z)
{
    e[idx]=y;
    w[idx]=z;
    ne[idx]=h[x];
    h[x]=idx++;
}

bool spfa()
{
//    memset(dist,0x3f,sizeof dist);由于我们只要记录每个点被更新的次数，所以dist[]的初始值对判断负环不参生影响 
    for(int i=1;i<=n;i++)//由于负环不一定是到源点的路径上产生的，所以要把所有点入队列 
    {
        q.push(i);
        vis[i]=true;
    }
    while(q.size())
    {
        int t=q.front();
        q.pop();
        vis[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;//源点到j的最短路径所含的边数等于源点到t的最短路径所含的边数+1 
                if(cnt[j]>=n) return true;//如果源点到j的最短路径所含的边数大于等于n，说明有负环 
                if(!vis[j])
                {
                    q.push(j);
                    vis[j]=true;
                }
            }
        }
    }
    return false;
}

int main()
{
    cin>>n>>m;
    memset(h,-1,sizeof h);
    idx=1;
    int x,y,z;
    while(m--)
    {
        cin>>x>>y>>z;
        add(x,y,z);
    }
    if(spfa()) puts("Yes");
    else puts("No");
    return 0;
}

spfa算法是判断负环的一个有效的方法，求最短路问题一般也用spfa算法（因为dijkstra算法不能解决带有负权边的最短路问题），还常常用于解决差分约束问题，这个我会在后面的博客中介绍，总之，spfa算法的应用范围比较广泛，而且复杂度比较低，是一个在比赛中经常用到的算法！