SPFA介绍及判负环的应用

SPFA介绍及判负环的应用

SPFA（队列优化算法） 是求单源最短路径的一种算法，他还有一个重要的功能是判断负环。

如果没必要判负环建议使用Dijkstra

主要思想及方法：

设一个数组用来存储源点到其他顶点的最短路径（过程中的当前最优解），初始化时，其他顶点为无穷。

再设立一个 队列 ，读取队头顶点，并将队头顶点 $now$ 出队（记得消除标记），将与点 $now$ 相连的所有点 $next$ 进行松弛操作，如果能更新值（即 $dis[next]>dis[now]+value[now][next]$），那么就更新。另外如果点 $next$ 没有在队列中要将点 $next$ 入队，如果已经在队列中了，那么就不用入队。

以此循环，直到队列为空就完成了单源最短路的求解。

判断负环的解释

若图中存在负环，那么在遍历到这个环的时候，最短路的值永远都在递减，我们就陷在这个死循环里出不来了。换一种说法，$1$ 到 $x$ 的最短路的边数一定不多于 $n-1$ 。否则至少有一个节点被重复经过，这说明存在环。如果经过该环依然能进行松弛操作更新 $dis$ 值，即存在负环。

判断负环的实现方法

Bellman-Ford 判断负环

Bellman-Ford 算法通过不断迭代计算最短路，每轮迭代至少有一个结点得到了最短路。所以，若图中没有负环，则最多经过 $n-1$ 轮迭代后算法结束。若第 $n$ 轮迭代仍有结点的最短路能被更新，则图中有负环。

SPFA判断负环

SPFA 是队列优化的 Bellman-Ford，所以我们可以类比 Bellman-Ford 判断负环。然而 SPFA 使用队列，无法直接得知在进行第几轮迭代。再观察 Bellman-Ford，我们发现第 $i$ 轮迭代实际是在计算最短路包含 $i$ 条边的结点。所以我们用 $cnt[x]$ 表示 $1$ 到 $x$ 的最短路包含的边数，$ cnt[1]=0 $。 每次 松弛操作 更新 $dis[y]$ 时，也用 $cnt[x]+1$ 更新 $cnt[y]$ 。此过程中若出现 $cnt[y]\ge n$ ，则 图中有负环 。

实现

模板题：传送

#include<bits/stdc++.h>
using namespace std;
#define MAXN 2005
#define MAXM 200005
#define ll long long
ll dis[MAXN];//存储最短路
ll cnt[MAXN];//存储边数
ll n,m;
int visit[MAXN];
struct node
{
    int to,next,val;
}edge[MAXM];
int head[MAXM];
int tot=0;
void add_edge(int from,int to,int val)
{
    edge[++tot].to=to;edge[tot].val=val;edge[tot].next=head[from];head[from]=tot;
}
void init()
{
    tot=0;
    for(int i=1;i<=n;i++)
    {
        visit[i]=0;
        head[i]=0;
        dis[i]=0x3f3f3f3f;
        cnt[i]=0;
    }
}

void build()
{
    for(int i=1;i<=m;i++)
    {
        int u,v,w;
        cin>>u>>v>>w;
        if(w<0)
        {
            add_edge(u,v,w);
        }
        else 
        {
            add_edge(u,v,w);
            add_edge(v,u,w);
        }
    }
}

bool spfa(int s,int n)//源点和节点个数
{
    dis[s]=0;
    queue <int> q;
    q.push(s);
    visit[s]=1;
    while(!q.empty())
    {
        int now=q.front();q.pop();
        visit[now]=0;
        for(int i=head[now];i;i=edge[i].next)
        {
            int next=edge[i].to;
            int val=edge[i].val;
            if(dis[now]+val<dis[next])
            {
                dis[next]=dis[now]+val;
                cnt[next]=cnt[now]+1;
                if(cnt[next]>=n) return 0;
                if(visit[next]==0)
                {
                    visit[next]=1;
                    q.push(next);
                }
            }
        }
    }
    return true;
}

void solve()
{
    cin>>n>>m;
    init();
    build();
    bool flag=spfa(1,n);
    if(flag==0) cout<<"YES"<<endl;
    else cout<<"NO"<<endl;
}

int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    int T;
    cin>>T;
    while(T--)
    {
        solve();
    }
    return 0;
}

判断方法2

我们也可以通过记录每个点的入队次数判断负环。如果某个节点的入队次数达到n次，则表明图中存在负环，没有最短路径。

#include<bits/stdc++.h>
using namespace std;
#define MAXN 2005
#define MAXM 200005
#define ll long long
ll dis[MAXN];//存储最短路
ll cnt[MAXN];//存储入队次数
ll n,m;
int visit[MAXN];
struct node
{
    int to,next,val;
}edge[MAXM];
int head[MAXM];
int tot=0;
void add_edge(int from,int to,int val)
{
    edge[++tot].to=to;edge[tot].val=val;edge[tot].next=head[from];head[from]=tot;
}
void init()
{
    tot=0;
    for(int i=1;i<=n;i++)
    {
        visit[i]=0;
        head[i]=0;
        dis[i]=0x3f3f3f3f;
        cnt[i]=0;
    }
}

void build()
{
    for(int i=1;i<=m;i++)
    {
        int u,v,w;
        cin>>u>>v>>w;
        if(w<0)
        {
            add_edge(u,v,w);
        }
        else 
        {
            add_edge(u,v,w);
            add_edge(v,u,w);
        }
    }
}

bool spfa(int s,int n)//源点和节点个数
{
    dis[s]=0;
    queue <int> q;
    q.push(s);
    visit[s]=1;
    while(!q.empty())
    {
        int now=q.front();q.pop();
        visit[now]=0;
        for(int i=head[now];i;i=edge[i].next)
        {
            int next=edge[i].to;
            int val=edge[i].val;
            if(dis[now]+val<dis[next])
            {
                dis[next]=dis[now]+val;               
                if(visit[next]==0)
                {
                    cnt[next]++;
                    if(cnt[next]>=n) return 0;
                    visit[next]=1;
                    q.push(next);
                }
            }
        }
    }
    return true;
}

void solve()
{
    cin>>n>>m;
    init();
    build();
    bool flag=spfa(1,n);
    if(flag==0) cout<<"YES"<<endl;
    else cout<<"NO"<<endl;
}

int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    int T;
    cin>>T;
    while(T--)
    {
        solve();
    }
    return 0;
}