POJ 3259 Wormholes

原题网址
题意：
一个既存在有向边（权值均为负），又存在无向边的图，询问图中是否存在负环路。
解析：
1、Bellman-Ford算法：
1）定义数组Distant[i]记录从源点s到顶点i的路径长度，初始化数组Distant[n]为正无穷, Distant[s]为0；以下操作循环执行至多n-1次，n为顶点数：对于每一条边e(u, v)，如果Distant[u] + w(u, v) < Distant[v]，则另Distant[v] = Distant[u]+w(u, v)。w(u, v)为边e(u,v)的权值；
若上述操作没有对Distant进行更新，说明最短路径已经查找完毕，或者部分点不可达，跳出循环。否则执行下次循环；
2）为了检测图中是否存在负环路，即权值之和小于0的环路。对于每一条边e(u, v)，如果存在Distant[u] + w(u, v) < Distant[v]的边，则图中存在负环路，即是说改图无法求出单源最短路径。否则数组Distant[n]中记录的就是源点s到各顶点的最短路径长度。可知，Bellman-Ford算法寻找单源最短路径的时间复杂度为O(V*E)；
3）AC代码:

#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <set>
#include <climits>
using namespace std;
const int MAXN=3*1e4+10;
const int MAXM=5*1e3+10;
const int maxx=0x3f3f3f3f;
struct node
{
    int s, e, c;
} z[MAXN];///存边
int N, M, W, sum, dis[MAXM];
bool BellmanFord()
{
    memset(dis,maxx,sizeof(dis));
    dis[1]=0;
    for(int i=0; i<N; i++)
    {
        for(int j=0; j<sum; j++)
        {
            if(dis[z[j].e]>dis[z[j].s]+z[j].c)
                dis[z[j].e]=dis[z[j].s]+z[j].c;
        }
    }
    for(int k=0; k<sum;k++)
    {
        if(dis[z[k].e]>dis[z[k].s]+z[k].c)
            return true;
    }
    return false;
}
int main()
{
    int F;
    cin>>F;
    while(F--)
    {
        cin>>N>>M>>W;
        int S, E, T;
        sum=0;
        while(M--)
        {
            cin>>S>>E>>T;
            z[sum++]=(node)
            {
                S,E,T
            };
            z[sum++]=(node)
            {
                E,S,T
            };
        }
        while(W--)
        {
            cin>>S>>E>>T;
            z[sum++]=(node)
            {
                S,E,-T
            };
        }
        bool flag=BellmanFord();
        if(flag)
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;
    }
    return 0;
}

2、SPFA算法（在SPFA增加一个记录入栈次数的数组，如果一个点入栈次数超过给定的点数N，则证明图中存在负环路)
AC代码:

#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <set>
#include <climits>
#include<iomanip>
using namespace std;
const int MAXN=5*1e2+10;
const int maxx=0x3f3f3f3f;
int time[MAXN][MAXN];
bool pin[MAXN];
int Distance[MAXN], z[MAXN];
int N, M, W, S, E, T;
bool SPFA()
{
    queue<int>Q;
    Q.push(1);
    pin[1]=true;
    Distance[1]=0;
    while(!Q.empty())
    {
        int m=Q.front();
        pin[m]=false;
        Q.pop();
        for(int i=1; i<=N; i++)
        {
            if(Distance[i]>Distance[m]+time[m][i])
            {
                Distance[i]=Distance[m]+time[m][i];
                if(!pin[i])
                {
                    Q.push(i);
                    pin[i]=true;
                    z[i]++;
                    if(z[i]>=N)
                        return true;
                }
            }
        }
    }
    return false;
}
int main()
{
    int F;
    scanf("%d",&F);
    while(F--)
    {
        scanf("%d%d%d",&N,&M,&W);
        memset(time,maxx,sizeof(time));
        for(int i=1; i<=N; i++)time[i][i]=0;
        while(M--)
        {
            scanf("%d%d%d",&S,&E,&T);
            if(time[S][E]>T)
            {
                time[S][E]=T;
                time[E][S]=T;
            }
        }
        while(W--)
        {
            scanf("%d%d%d",&S,&E,&T);
            time[S][E]=-T;
        }
        memset(Distance,maxx,sizeof(Distance));
        memset(pin,false,sizeof(pin));
        memset(z,0,sizeof(z));
        if(SPFA())
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;
    }
    return 0;
}