POJ-2679（最短路+负环判断）

最新推荐文章于 2021-07-07 15:42:53 发布

还有多远

最新推荐文章于 2021-07-07 15:42:53 发布

阅读量593

点赞数

分类专栏：每天A一道题图论

本文链接：https://blog.csdn.net/uuuououlcz/article/details/32098607

版权

每天A一道题同时被 2 个专栏收录

145 篇文章 2 订阅

订阅专栏

图论

28 篇文章 0 订阅

订阅专栏

题目中节点数目很多（V<=1100），而边却较少（E <= 5000），因此SPFA的ElogE会明显优于Dijsktra的N^2

需要注意的是SPFA是处理入边邻接矩阵的，所以需要在SPFA处理之前根据输入的出边得到合法的入边

细节点：

（1）为处理单节点负环，队列节点出队后，应立即将对应节点的inq标志置为false

（2）题目要求输出时，先判断有无路径，再判断有无负环，所以在发现负环时，应先看dis[S][D]是否仍为无穷

#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;
#define MAX_VERTEX  1100
#define MAX_FEE     200
#define MAX_LENGTH  99999999
#define MAX_COST    99999999

/*********************** datas ***********************/
int N, M, S, D;
struct Edge{
    int to;
    int length;
    int cost;
    Edge(int t, int l, int c):to(t), length(l), cost(c){}
};
vector<Edge> out[MAX_VERTEX], in[MAX_VERTEX];
int  path[MAX_VERTEX][2];
int  times[MAX_VERTEX];
bool inq[MAX_VERTEX];

/********************** procedures ********************/
bool input()
{
    if(scanf("%d%d", &N, &M) != 2) return false;
    for(int i = 0; i < N; ++i){
        out[i].clear();
        in[i].clear();
    }
    
    scanf("%d%d", &S, &D);
    int u, v, fuv, l, fvu;
    for(int i = 0; i < M; ++i){
        while(getchar() != '(') ;
        scanf("%d,%d,%d[%d]%d)", &u, &v, &fuv, &l, &fvu);
        out[u].push_back(Edge(v, l, fuv));
        out[v].push_back(Edge(u, l, fvu));
    }
    return true;
}
void initInRoads()
{
    for(int i = 0; i < N; ++i){
    //find all rewarding roads leaving i
        vector<Edge>& v = out[i];
        int k = v.size();
        if(k > 1){
        //find minimal fee
            int fee = MAX_FEE, j, n = k;
            for(j = 0; j < n; ++j){
                if(v[j].cost < fee) fee = v[j].cost;
            }
            //erase all roads except those have minimal fee
            k = 0;
            for(j = 0; j < n; ++j){
                if(v[j].cost == fee) v[k++] = v[j];
            }
        }
        //set corresponding in roads
        for(int j = 0; j < k; ++j){
            in[v[j].to].push_back(Edge(i, v[j].length, v[j].cost));
        }
    }
}
void spfa()
{
//initialize
    memset(times, 0, N << 2);
    memset(inq, false, N);
    for(int i = 0; i < N; ++i){
        path[i][0] = MAX_LENGTH;
        path[i][1] = MAX_COST;
    }
    path[D][0] = path[D][1] = 0;
//main process
    queue<int> q;
    q.push(D);
    inq[D] = true;
    while(!q.empty()){
        int u = q.front(); q.pop(); inq[u] = false;
        if(++times[u] > N){//negative cycle
            if(path[S][0] < MAX_LENGTH) puts("UNBOUND");
            else puts("VOID");
            return;
        }
        const vector<Edge>& vec = in[u];
        for(int i = 0, n = vec.size(); i < n; ++i){
            int v = vec[i].to;
            if(path[v][1] > path[u][1] + vec[i].cost ||
               path[v][1] == path[u][1] + vec[i].cost &&
               path[v][0] > path[u][0] + vec[i].length){
                path[v][1] = path[u][1] + vec[i].cost;
                path[v][0] = path[u][0] + vec[i].length;
                if(!inq[v]){
                    q.push(v);
                    inq[v] = true;
                }
            }
        }
    }
    if(path[S][0] < MAX_LENGTH) printf("%d %d\n", path[S][1], path[S][0]);
    else puts("VOID");
}

int main()
{
    while(input()){
        initInRoads();
        spfa();
    }
    return 0;
}