单源最短路 判负环

Wormholes http://poj.org/problem?id=3259

spfa 2e

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
const int inf=0x3f3f3f3f;
const int M=1024;
class Spfa { ///单源最短路o(2*ME)
    typedef int typec;///边权的类型
    static const int ME=1000010;///边的个数
    static const int MV=1000010;///点的个数
    struct E {
        int v,next;
        typec w;
    } e[ME];
    int n,le,head[MV],inque[MV];
    typec dist[MV];
    bool used[MV];
    queue<int> q;
public:
    void init(int tn) { ///传入点的个数
        n=tn;
        le=0;
        mt(head,-1);
    }
    void add(int u,int v,typec w) {
        e[le].v=v;
        e[le].w=w;
        e[le].next=head[u];
        head[u]=le++;
    }
    bool solve(int s) { ///传入起点，下标0开始,存在负环返回false
        for(int i=0; i<n; i++) {
            dist[i]=inf;
            used[i]=true;
            inque[i]=0;
        }
        used[s]=false;
        dist[s]=0;
        inque[s]++;
        while(!q.empty()) q.pop();
        q.push(s);
        while(!q.empty()) {
            int u=q.front();
            q.pop();
            used[u]=true;
            for(int i=head[u]; ~i; i=e[i].next) {
                int v=e[i].v;
                if(dist[v]>dist[u]+e[i].w) {
                    dist[v]=dist[u]+e[i].w;
                    if(used[v]) {
                        used[v]=false;
                        q.push(v);
                        inque[v]++;
                        if(inque[v]>n) return false;
                    }
                }
            }
        }
        return true;
    }
    typec getdist(int id) {
        return dist[id];
    }
} gx;

int main() {
    int t,n,m,w,x,y,z;
    while(~scanf("%d",&t)) {
        while(t--){
            scanf("%d%d%d",&n,&m,&w);
            gx.init(n);
            while(m--) {
                scanf("%d%d%d",&x,&y,&z);
                x--;
                y--;
                gx.add(x,y,z);
                gx.add(y,x,z);
            }
            while(w--){
                scanf("%d%d%d",&x,&y,&z);
                x--;
                y--;
                gx.add(x,y,-z);
            }
            if(!gx.solve(0)) puts("YES");
            else puts("NO");
        }
    }
    return 0;
}

 Bellman_ford 单源最短路o(MV*ME)

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
const int inf=0x3f3f3f3f;
const int M=1024;
class Bellman_ford { ///单源最短路o(MV*ME)
    typedef int typec;///边权的类型
    static const int ME=1000010;///边的个数
    static const int MV=1000010;///点的个数
    struct E {
        int u,v,next;
        typec w;
    } e[ME];
    int n,le,head[MV];
    bool used[MV];
    typec dist[MV];
public:
    void init(int tn) { ///传入点的个数
        n=tn;
        le=0;
        mt(head,-1);
    }
    void add(int u,int v,typec w) {
        e[le].u=u;
        e[le].v=v;
        e[le].w=w;
        e[le].next=head[u];
        head[u]=le++;
    }
    bool solve(int s) {  ///传入起点，下标0开始，为真最短路成功,为假存在负环
        for(int i=0; i<n; i++) {
            used[i]=true;
            dist[i]=inf;
        }
        used[s]=false;
        dist[s]=0;
        for(int i=head[s]; ~i; i=e[i].next){
            int v=e[i].v;
            dist[v]=min(dist[v],e[i].w);
        }
        for(int i=1; i<n; i++) {
            typec sma=inf;
            int p;
            for(int j=0; j<n; j++) {
                if(used[j]&&sma>dist[j]) {
                    p=j;
                    sma=dist[j];
                }
            }
            used[p]=false;
            for(int j=head[p]; ~j; j=e[j].next) {
                int v=e[j].v;
                if(!used[v]) continue;
                dist[v]=min(dist[v],e[j].w+dist[e[j].u]);
            }
        }
        bool flag=true;
        int j;
        for(j=0; flag&&j<=n; j++) {
            flag=false;
            for(int i=0; i<n; i++) {
                for(int k=head[i]; ~k; k=e[k].next) {
                    if(dist[e[k].v]>e[k].w+dist[i]) {
                        dist[e[k].v]=e[k].w+dist[i];
                        flag=true;
                    }
                }
            }
        }
        return j<=n;
    }
    typec getdist(int id){
        return dist[id];
    }
}gx;
int main() {
    int t,n,m,w,x,y,z;
    while(~scanf("%d",&t)) {
        while(t--) {
            scanf("%d%d%d",&n,&m,&w);
            gx.init(n);
            while(m--) {
                scanf("%d%d%d",&x,&y,&z);
                x--;
                y--;
                gx.add(x,y,z);
                gx.add(y,x,z);
            }
            while(w--) {
                scanf("%d%d%d",&x,&y,&z);
                x--;
                y--;
                gx.add(x,y,-z);
            }
            if(!gx.solve(0)) puts("YES");
            else puts("NO");
        }
    }
    return 0;
}

end