HDU1874——SPFA

很简单的题，回顾下SPFA算法。

//
//  main.cpp
//  SPFA
//
//  Created by jinyu on 2018/7/12.
//  Copyright © 2018年 jinyu. All rights reserved.
//

#include <iostream>
#include <queue>
#include <time.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int visited[200+77];
int arc[200+77][200+77];
int dist[200+77];
int b[200+7][200+7];
int N;
queue<int> Q;

void init(){
    for(int i = 0;i<200+77;i++){
        dist[i] = INF;
        for(int j = 0;j<200+77;j++)
        {
            if(i!=j)
                arc[i][j] = INF;
            else
                arc[i][j] = 0;
        }
    }
    
}

void SPFA(int s){
    for(int i = 0;i<N;i++)
        visited[i] = 0;
    visited[s] = 1;
    dist[s] = 0;
    Q.push(s);
    int i,v;
    while(!Q.empty()){
        v = Q.front();
        Q.pop();
        visited[v] = 0;
        for(i = 0;i<N;i++){
            if(dist[i] > dist[v] + arc[v][i]){
                dist[i] = dist[v] + arc[v][i];
                if(!visited[i]){
                    visited[i] = 1;
                    Q.push(i);
                }
            }
        }
    }
    
}

//void SPFA1(int s){
//    memset(visited,0,sizeof(visited));
//    dist[s] = 0;
//    Q.push(s);
//    visited[s] = 1;
//    int i,v;
//    while(!Q.empty()){
//        v = Q.front();
//        Q.pop();
//        visited[v] = 0;
//        for(i = 1;i<=b[v][0];i++){
//            if(dist[b[v][i]] > dist[v] + arc[v][b[v][i]]){
//                dist[b[v][i]] = dist[v] + arc[v][b[v][i]];
//                if(!visited[b[v][i]]){
//                    Q.push(b[v][i]);
//                    visited[b[v][i]] = 1;
//                }
//            }
//        }
//    }
//}

int flag = 0;
void SPFAdfs(int s){
    
    if(flag)
        return ;
    visited[s] = 1;
    int i,v;
    v = s;
    visited[v] = 0;
    for(i = 0;i<N;i++){
        if(dist[i] > dist[v] + arc[v][i]){
            dist[i] = dist[v] + arc[v][i];
                if(!visited[i])
                    SPFAdfs(i);
                else{
                    flag = 1;
                }
        }
    }
}

void Dijkstra(int start){
    memset(visited, 0, sizeof(visited));
    for(int i = 0;i<N;i++){
        dist[i] = arc[start][i];
    }
    visited[start] = 1;
    
    for(int i = 0;i<N-1;i++){
        int min = INF;
        int u = 0;
        for(int j = 0;j<N;j++){
            if(!visited[j] && dist[j]<min){
                min = dist[j];
                u = j;
            }
        }
        visited[u] = 1;
        
        for(int k = 0;k<N;k++){
            if (!visited[k] && dist[k] > dist[u] + arc[u][k]){
                dist[k] = dist[u] + arc[u][k];
            }
        }
    }
}


int main(){
    
    int M;
    while(cin>>N>>M)
    {
        init();
        int mm = M;
        while(mm--){
            int A,B,X;
            cin>>A>>B>>X;
            if(X<arc[A][B]){
                arc[A][B] = X;
                arc[B][A] = X;
            }
        }
        int start,end;
        cin>>start>>end;
        memset(visited,0,sizeof(visited));
        dist[start] = 0;
        SPFAdfs(start);
        //Dijkstra(start);
        if(flag){
            cout<<"有负环"<<endl;
            return 0;
        }
        
        if(dist[end]!=INF)
            cout<<dist[end]<<endl;
        else
            cout<<-1<<endl;
        
        //cout << "Totle Time : " << (double)clock() /CLOCKS_PER_SEC<< "s" << endl;

    }
    return 0;
    
}



/**
 Dijkstra:
 0.017753
 0.018455
 
 
 SPFA(未优化)：
 0.012394
 0.012924
 
 SPFA1:
 0.015374
 0.015926
 
 SPFA(dfs):
 0.01124
 0.01181
 */