洛谷 P3385 贝尔曼福特判负环

https://www.luogu.org/problemnew/show/P3385

题目描述

暴力枚举/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

说明

n≤2000n\leq 2000n≤2000 m≤3000m\leq 3000m≤3000 −10000≤w≤10000-10000\leq w\leq 10000−10000≤w≤10000 T≤10T\leq 10T≤10 建议复制输出格式中的字符串。 本题数据感谢@negiizhao的精心构造，请不要使用玄学算法 本题数据有更新

思路：Bellman-Ford

#include<iostream>
#include<cstdio>
#include<cstring>
#define INF 0x3f3f3f3f
using namespace std;

struct edge
{
    int from,to,cost;
};

edge E[6005];
int d[2005];
int n,m;//顶点数 边数

bool find_negative_loop(int s)
{
    memset(d,INF,sizeof(d));
    d[s]=0;
    for(int i=0;i<n;i++)//最多执行n-1次
    {
        for(int j=0;j<m;j++)
        {
            edge e=E[j];
            if(d[e.from]!=INF&&d[e.to]>d[e.from]+e.cost)
            {
                d[e.to]=d[e.from]+e.cost;
                if(i==n-1)//第n次仍然更新了 存在负圈
                    return 1;
            }
        }
    }
    return 0;
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d %d",&n,&m);
        int t1,t2,t3;
        for(int i=0;i<m;i++)
        {
            scanf("%d %d %d",&t1,&t2,&t3);
            if(t3>=0)//双向
            {
                E[i].from=t1,E[i].to=t2,E[i].cost=t3;
                ++m,++i;
                E[i].from=t2,E[i].to=t1,E[i].cost=t3;
            }
            else
                E[i].from=t1,E[i].to=t2,E[i].cost=t3;
        }
        if(find_negative_loop(1))
            printf("YE5\n");
        else
            printf("N0\n");
    }
    return 0;
}

SPFA(毒瘤数据卡了dfs_spfa 所以只能写bfs版的了)

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

const int maxn=2005;
const int maxm=3005;

struct Edge
{
    int to,nxt,dis;
}edge[maxm<<1];

int d[maxn],head[maxn],cnt[maxn];
bool vis[maxn];
int n,m,tot;//顶点数 边数

inline void addedge(int u,int v,int dis)
{
    edge[++tot].to=v,edge[tot].nxt=head[u],edge[tot].dis=dis,head[u]=tot;
}

bool spfa(int u)
{
    queue<int> q;
    q.push(1);
    vis[1]=1;
    ++cnt[1];
    while(!q.empty())
    {
        int u=q.front();
        q.pop(),vis[u]=0;
        for(int i=head[u];i;i=edge[i].nxt)
        {
            int v=edge[i].to;
            if(d[v]>d[u]+edge[i].dis)
            {
                d[v]=d[u]+edge[i].dis;
                if(!vis[v])
                {
                    q.push(v),vis[v]=1;
                    if(++cnt[v]>=n)
                        return 1;
                }
            }
        }
    }
    return 0;
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        tot=0;
        memset(d,INF,sizeof(d));
        memset(vis,0,sizeof(vis));
        memset(head,0,sizeof(head));
        memset(cnt,0,sizeof(cnt));
        scanf("%d %d",&n,&m);
        int t1,t2,t3;
        for(int i=0;i<m;i++)
        {
            scanf("%d %d %d",&t1,&t2,&t3);
            addedge(t1,t2,t3);
            if(t3>=0)//双向
                addedge(t2,t1,t3);
        }
        d[1]=0;
        if(spfa(1))
            printf("YE5\n");
        else
            printf("N0\n");
    }
    return 0;
}