最短路SPFA优化及判断负环

最新推荐文章于 2026-06-04 10:14:57 发布

原创最新推荐文章于 2026-06-04 10:14:57 发布 · 300 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

ACM最短路SPFA 专栏收录该内容

4 篇文章

订阅专栏

本文深入探讨了负环检测算法的实现，通过两种不同的代码示例，详细解释了如何使用SPFA算法进行负环判断。文章首先展示了使用宏定义和模板函数的C++实现，随后提供了另一种更为清晰的优化版实现，帮助读者理解算法原理及其在实际问题中的应用。

判断负环

#include<bits/stdc++.h>
#define IL inline
#define RI register int
#define N 100086
#define clear(a) memset(a,0,sizeof a)
#define rk for(RI i=1;i<=n;i++)
using namespace std;
IL void read(int &x)
{
    int f=1;x=0;char s=getchar();
    while(s>'9'||s<'0'){if(s=='-')f=-1;s=getchar();}
    while(s<='9'&&s>='0'){x=x*10+s-'0';s=getchar();}
    x*=f;
}
int n,m,T;
struct code{int u,v,w;}edge[N];
bool vis[N];
int head[N],tot,dis[N],cnt[N];
IL void add(int x,int y,int z){edge[++tot].u=head[x];edge[tot].v=y;edge[tot].w=z;head[x]=tot;}
IL bool spfa(int now)
{
    rk vis[i]=false,dis[i]=2147483647,cnt[i]=false;
    queue<int>q;
    q.push(now);
    vis[now]=true;
    dis[now]=0;
    while(!q.empty())
    {
        int u=q.front();q.pop();vis[u]=false;
        if(cnt[u]>=n)return true;
        for(RI i=head[u];i;i=edge[i].u)
        {
            if(dis[edge[i].v]>dis[u]+edge[i].w)
            {
                dis[edge[i].v]=dis[u]+edge[i].w;
                if(!vis[edge[i].v])
                {
                    q.push(edge[i].v);
                    vis[edge[i].v]=true;
                    cnt[edge[i].v]++;
                    if(cnt[edge[i].v]>=n)return true;
                }
            }
        }
    }
    return false;
}
int main()
{
    read(T);
    while(T--)
    {
        read(n),read(m);
        tot=0;clear(head);
        for(RI i=1,u,v,w;i<=m;i++)
        {
            read(u),read(v),read(w);
            if(w<0)add(u,v,w);
            else add(u,v,w),add(v,u,w);
        }
        puts(spfa(1)?"YE5":"N0");
    }
}

优化

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
#include <vector>
using namespace std;
const int maxn = 1010;
const int INF = 1000000;
int path[maxn];
int dis[maxn];
int inq[maxn];
int shortest[maxn];
int n,m;
queue<int> q;
struct Edge
{
    int to;
    int w;
};
vector<Edge> ve[maxn];
void SPFA(int v0)
{
    int u;
    memset(inq,0,sizeof(inq));
    for(int i=0; i<n; i++)
    {
        dis[i]=INF;
        path[i]=v0;
    }
    dis[v0]=0;//起点
    while(!q.empty())
        q.pop();
    q.push(v0);
    inq[v0]++;
    while(!q.empty())
    {
        u=q.front();
        q.pop();
        inq[u]--;
        for(int i=0; i<ve[u].size(); i++)
        {
            if(dis[ve[u][i].to]>dis[u]+ve[u][i].w)
            {
                dis[ve[u][i].to]=dis[u]+ve[u][i].w;
                path[ve[u][i].to]=u;
                if(!inq[ve[u][i].to])
                {
                    q.push(ve[u][i].to);
                    inq[ve[u][i].to]++;
                }
            }
        }
    }

}
int main()
{
    int u,v,w;
    Edge e;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(int i=0; i<m; i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            e.to=v;
            e.w=w;
            ve[u].push_back(e);
        }
        SPFA(0);
        for(int i=1; i<n; i++)
        {
            printf("%d: %d   ",i,dis[i]);
            memset(shortest,0,sizeof(shortest));
            int k=0;
            shortest[k]=i;
            while(path[shortest[k]]!=0)
            {
                k++;
                shortest[k]=path[shortest[k-1]];
            }
            shortest[++k]=0;
            for(int j=k; j>0; j--)
            {
                printf("%d->",shortest[j]);
            }
            printf("%d\n",shortest[0]);
        }

    }
    return 0;
}