负环...坑点

题目描述

暴力枚举/SPFA/Bellman-ford/奇怪的贪心/超神搜索

寻找一个从顶点1所能到达的负环，负环定义为：一个边权之和为负的环。

输入输出格式

输入格式：

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

第一行两个正整数N M，表示图有N个顶点，M条边

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

输出格式：

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

输入输出样例

输入样例#1： 复制

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

输出样例#1： 复制

N0
YE5

很平常的判环，spfa跑就行了，但是记录一个坑点：


初始化的时候队列也要清空


代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn=6010;
int t,m,n;
struct edge
{
    int dis,to,next;
}e[maxn<<1];
int head[maxn],cnt;
inline void addedge(int from,int to,int dis)
{
    e[++cnt].next=head[from];
    e[cnt].dis=dis;
    e[cnt].to=to;
    head[from]=cnt;
}
int dis[maxn],vis[maxn],dfn[maxn];
queue < int > q;
int spfa(int s)
{
    for(int i=1;i<=n;i++)
    {
        dis[i]=0x7fffffff;
        vis[i]=0;
        dfn[i]=0;
    }
    //dfn[s]=1;
    vis[s]=1;
    dis[s]=0;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=0;
        if(dfn[u]>n)
        return 1;
        for(int i=head[u];i;i=e[i].next)
        {
            int v=e[i].to;
            if(dis[v]>dis[u]+e[i].dis)
            {
                dis[v]=dis[u]+e[i].dis;
                if(vis[v]==0)
                {
                    dfn[v]++;
                    q.push(v);
                    vis[v]=1;
                    if(dfn[v]>=n)
                    return 1;
                }
            }
        }
    }
    return 0;
}
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        for(int i=1;i<=m;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            if(z<0)
            addedge(x,y,z);
            else addedge(x,y,z),addedge(y,x,z);
        }
        if(spfa(1)==1)
        printf("YE5
");
        else printf("N0
");
        memset(head,0,sizeof(head));
        cnt=0;
        while(!q.empty())q.pop();//这里，初始化！！！
    }
    return 0;
}