SPFA判负环

【SPFA】

在介绍判负环之前，我先简单介绍一下SPFA算法

（以下的内容摘自百度）

首先呢，SPFA（Shortest Path Faster Algorithm）算法是求单源最短路径的一种算法，它有一个重要的功能是判负环（在差分约束系统中会得以体现）

我们先说一下松弛操作，它的原理是著名的定理：“三角形两边之和大于第三边”，在信息学中我们叫它三角不等式。若用 u 来松弛 v，就是判断是否 dis[ v ] > dis[ u ] + w[ u , v ]，如果该式成立则将 dis[ v ] 更新到 dis[ u ] + w[ u , v ]，否则不变

SPFA相当于是Bellman-Ford算法的一个优化版本，在Bellman-Ford算法中，很多松弛操作其实都是没有必要的，例如对于一条从 x 到 y 的边，如果连 x 都还没被松弛，那 y 肯定也还不能被 x 松弛，为了避免“用一个还没有被松弛的点去松弛另外的点”的情况，我们用一个队列来存储已经被松弛过的点，然后用队列里的点去松弛其他点，这就是SPFA算法的基本思想

下面是具体的操作：

我们先把起点加入队列中，每次取出队首元素 u，然后尝试松弛点 u 能到达的点 v，若点 v 能被松弛且点 v 还没有被加进队列里，那么我们就把点 v 入队，不断地这样操作，直到队列为空。这样的话，只要最短路存在，那么我们就一定能求出最短路

还有一个要注意的地方就是SPFA有时会被恶意数据卡掉，如果没有负边权的话还是建议使用Dijkstra

 

【bfs版】

首先我们要知道，对于一个不存在负环的图，从起点到任意一个点最短距离经过的点最多只有 n 个

这样的话，我们用 cnt[ i ] 表示从起点（假设就是 1）到 i 的最短距离包含点的个数，初始化 cnt[ 1 ] = 1，那么当我们能够用点 u 松弛点 v 时，松弛时同时更新 cnt[ v ] = cnt[ u ] + 1，若发现此时 cnt[ v ] > n，那么就存在负环

还有一种方法是记录每个点的入队次数，入队次数大于 n 就说明有负环，但是这样做一般都要比上面的方法慢。举个例子，在一个由 n 个点构成的负环中，这个方法要绕环 n 次，而上面的方法绕环 1 次就行了

代码（Yes 是存在负环，No 是不存在负环，图是联通的）：

#include<queue>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 10005
#define M 20005
using namespace std;
int n,m,t,oo;
int v[M],w[M],next[M];
int d[N],cnt[N],first[N];
bool flag,vis[N];
void add(int x,int y,int z)
{
        t++;
        next[t]=first[x];
        first[x]=t;
        v[t]=y;
        w[t]=z;
}
bool SPFA(int s)
{
        int x,y,i,j;
        queue<int>q;
        memset(d,127,sizeof(d));
        memset(vis,false,sizeof(vis));
        while(!q.empty())  q.pop();
        d[s]=0;
        cnt[s]=1;
        q.push(s);
        vis[s]=true;
        while(!q.empty())
        {
                x=q.front();
                q.pop();
                vis[x]=false;
                for(i=first[x];i;i=next[i])
                {
                        y=v[i];
                        if(d[y]>d[x]+w[i])
                        {
                                d[y]=d[x]+w[i];
                                cnt[y]=cnt[x]+1;
                                if(cnt[y]>n)
                                  return false;
                                if(!vis[y])
                                {
                                        q.push(y);
                                        vis[y]=true;
                                }
                        }
                }
        }
        return true;
}
int main()
{
        int x,y,z,i;
        scanf("%d%d",&n,&m);
        for(i=1;i<=m;++i)
        {
	        scanf("%d%d%d",&x,&y,&z);
                add(x,y,z);
                add(y,x,z);
        }
        flag=SPFA(1);
        if(!flag)  printf("Yes\n");
        else  printf("No\n");
        return 0;
}

 

【dfs版】

基于 dfs 版的 SPFA 相当于是把"先进先出"的队列换成了"先进后出"的栈

也就是说，每次都以刚刚松弛过的点来松弛其他的点，如果能够松弛点 x 并且 x 还在栈中，那图中就有负环

一般来说的话，若存在负环，那么 dfs 会比 bfs 快

但是如果不存在负环，dfs 可能会严重影响求最短路的效率，要谨慎使用

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 10005
#define M 20005
using namespace std;
int n,m,t;
int d[N],first[N];
int v[M],w[M],next[M];
bool flag,vis[N];
void add(int x,int y,int z)
{
	t++;
	next[t]=first[x];
	first[x]=t;
	v[t]=y;
	w[t]=z;
}
void spfa(int x)
{
	int i,j;
	vis[x]=true;
	for(i=first[x];i;i=next[i])
	{
		j=v[i];
		if(d[j]>d[x]+w[i])
		{
			if(vis[j])
			{
				flag=false;
				return;
			}
			d[j]=d[x]+w[i];
			spfa(j);
		}
	}
	vis[x]=false;
}
int main()
{
	int x,y,z,i;
	scanf("%d%d",&n,&m);
	for(i=1;i<=m;++i)
	{
		scanf("%d%d%d",&x,&y,&z);
		add(x,y,z);
		add(y,x,z);
	}
	memset(d,127,sizeof(d));
	d[1]=0;
	flag=true;
	spfa(1);
	if(!flag)  printf("Yes");
	else  printf("No");
	return 0;
}