用SPFA判断负环的方法及其优化

题目链接：洛谷：【模板】负环
题目描述：判断负环

---

输入格式
第一行一个正整数T表示数据组数，对于每组数据：

• 第一行两个正整数N M，表示图有N个顶点，M条边
• 接下来M行，每行三个整数a b w，表示a->b有一条权值为w的边（若w<0则为单向，否则双向）

---

输出格式
共T行。

• 对于每组数据，存在负环则输出一行”YE5”(不含引号)，否则输出一行”N0”(不含引号)。

---

判负环的主要思路就是SPFA。
SPFA有两种实现方法。一个是BFS一个是DFS。

BFS

BFS版的判断标准：是否存在某个节点入队超过n次
BFS_SPFA的期望时间复杂度是O(ke)，其中k为所有顶点进队的平均次数。
如果存在负环嘛，这个期望的时间复杂度就真的是期望了。

DFS

DFS版判断标准：否存在一点在一条路径上出现多次来判断。
时间复杂度如果没记错是O(nlogn)的。

显然可见，bfs判别负环不稳定，相当于限深度搜索，但是设置得好的话还是没问题的。
dfs的话判断负环很快

//这不是正解！会TLE！会TLE！会TLE！
#include
#include
#define INF 1e9+7
#define maxn 200005
#define maxm 200005
using namespace std;

struct data{int v,t,nxt;}edges[maxm<<1];
int head[maxn],cnt,d[maxn];
void insert(int u,int v,int t){edges[++cnt]=(data){v,t,head[u]};head[u]=cnt;}
bool vis[maxn],flag;

int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

void DFS_SPFA(int u){
    vis[u]=true;
    for(int i=head[u];i;i=edges[i].nxt){
        int v=edges[i].v;
        if(d[u]+edges[i].tif(vis[v]){
                flag=true;return ;
            }else{
                DFS_SPFA(v);
            }
        }
    }
    vis[u]=false;
}

int main(){
    int T=read();
    while(T--){
        memset(head,0,sizeof(head));
        memset(d,63,sizeof(d));
        memset(vis,false,sizeof(vis));
        d[1]=0;cnt=0;
        int n=read(),m=read();
        for(int a,b,v,i=1;i<=m;i++){
            a=read();b=read();v=read();
            insert(a,b,v);
            if(v>=0){
                insert(b,a,v);
            }
        }
        flag=false;
        DFS_SPFA(1);
        if(flag){
            printf("YE5\n");
        }else{
            printf("N0\n");
        }
    }
    return 0;
}

DFS优化

这个优化是我从出题人sama那里问出来的。表示感谢啦啦啦~
//不给题解就捣蛋（捂脸）

表示感谢后，严肃的扯扯优化。

既然我们只需要判断负环，那么就相当于我们需要找到一条权值和为负的回路。
既然我们只需要找到权值和为负的回路，那不妨使距离数组d初始化为0。
这样处理后，第一次拓展只会拓展到与起点相连边权为负的边。
那么我们就分别枚举所有的点作为起点，如果已经找到一个负环就不再继续枚举。
根据SPFA，我们找到的负环一定包含当前枚举的这个点。（因为这个点出现了两次啊）
正确性相当的显然。

然后放出丑陋的代码
我的代码跑了接近400ms。个人还是挺满意的啦啦啦~

#include
#include
#define INF 1e9+7
#define maxn 200005
#define maxm 200005
using namespace std;

struct data{int v,t,nxt;}edges[maxm<<1];
int head[maxn],cnt,d[maxn];
void insert(int a,int b,int v){edges[++cnt]=(data){b,v,head[a]};head[a]=cnt;}
bool vis[maxn],flag;

int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

void DFS_SPFA(int u){
    if(flag) return ;
    vis[u]=true;
    for(int i=head[u];i;i=edges[i].nxt){
        if(flag) return ;
        int v=edges[i].v;
        if(d[u]+edges[i].tif(vis[v]){
                flag=true;
                return ;
            }else{
                DFS_SPFA(v);
            }
        }
    }
    vis[u]=false;
}

int main(){
    int T=read();
    while(T--){
        int n=read(),m=read();
        memset(d,0,sizeof(d));
        memset(vis,0,sizeof(vis));
        memset(head,0,sizeof(head));
        cnt=0;
        flag=false;
        d[1]=0;

        for(int a,b,v,i=1;i<=m;i++){
            a=read();b=read();v=read();
            insert(a,b,v);
            if(v>=0){
                insert(b,a,v);
            }
        }
        for(int i=1;i<=n;i++){
            DFS_SPFA(i);
            if(flag) break;
        }
        if(flag){
            printf("YE5\n");
        }else{
            printf("N0\n");
        }
    }
    return 0;
}