hdu 2544 最短路 （链式前向星 + SPFA）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2544

参考：http://www.cppblog.com/menjitianya/archive/2015/11/19/212292.html

代码：

//链式前向星 + spfa 求最短路
#include<cstdio>
#include<algorithm>
#include<queue>
#define M 10005
#define N 105
#define INF 1e7
using namespace std;
struct edge //链式前向星
{
    int u, v, w, next;
}es[M];
int d[N], head[N], ecnt;    //head[u]指向起点为u的一条边，d[u]表示从起始点1到i的距离
int n, m;
queue<int> q;

void add(int u, int v, int w)
{
    es[ecnt] = {u, v, w, head[u]};
    head[u] = ecnt++;
}

void init()
{
    ecnt = 0;
    for(int i = 0; i <= n; i++) {
        head[i] = -1;   //-1表示空地址
    }
    if(!q.empty()) {
        q.pop();
    }
}

bool spfa()
{
    int viscnt[N];  //记录该点已被访问次数
    bool inq[N];    //记录该点是否在队列中
    for(int i = 1; i <= n; i++) {   //初始化
        d[i] = INF;
        inq[i] = false;
        viscnt[i] = 0;
    }
    q.push(1);  //起始点1入队
    d[1] = 0;   //到起始点1的距离为0
    inq[1] = true;

    while(!q.empty()) {
        int x = q.front();
        q.pop();
        inq[x] = false;

        viscnt[x]++;    //该点访问次数+1
        if(viscnt[x] > n) {     //若该点访问次数超过n，则说明存在负环
            return false;
        }

        //与Bellman-Ford算法类似
        for(int i = head[x]; i != -1; i = es[i].next) {
            int v = es[i].v;
            if(d[v] > d[x] + es[i].w) {     //松弛操作，更新到其它可到达的点的最短距离
                d[v] = d[x] + es[i].w;
                if(!inq[v]) {   //如果被松弛的点不在队列中，则入队
                    q.push(v);
                    inq[v] = true;
                }
            }
        }
    }

    return true;
}

void solve()
{
    if(!spfa()) printf("error\n");
    else printf("%d\n", d[n]);
}

int main()
{
    int u, v, w;
    while(scanf("%d %d", &n, &m)) {
        if(n == 0 && m == 0) break;
        init();
        for(int i = 0; i < m; i++) {
            scanf("%d %d %d", &u, &v, &w);
            //这道题的路径是双向的
            add(u, v, w);
            add(v, u, w);
        }

        solve();
    }

    return 0;
}

dijkstra算法 + 优先队列代码（结果：Wrong Answer）（按照《挑战程序设计竞赛》里的代码写的，不知道是哪里错了）

#include<bits/stdc++.h>
#define INF 1e7
#define MAX_V 105
using namespace std;
struct edge
{
    int to, cost;
};
typedef pair<int, int> P;
int n, m;
vector<edge> G[MAX_V];
int d[MAX_V];

int dijkstra(int s)
{
    priority_queue<P, vector<P>, greater<P> > que;
    fill(d+1, d+n+1, INF);
    d[s] = 0;
    que.push(P(0, s));

    while(!que.empty()) {
        P p = que.top();
        que.pop();
        int v = p.second;
        if(d[v] < p.first) continue;
        for(int i = 0; i < G[v].size(); i++) {
            edge e = G[v][i];
            if(d[e.to] > d[v] + e.cost) {
                d[e.to] = d[v] + e.cost;
                que.push(P(d[e.to], e.to));
            }
        }
    }
    return d[n];
}

int main()
{
    int a, b, c;
    while(scanf("%d %d", &n, &m)) {
        if(n == 0 && m == 0) break;
        for(int i = 0; i < m; i++) {
            scanf("%d %d %d", &a, &b, &c);
            edge temp1, temp2;
            temp1.to = b;
            temp1.cost = c;
            temp2.to = a;
            temp2.cost = c;
            G[a].push_back(temp1);
            G[b].push_back(temp2);
        }

        int ans = dijkstra(1);
        printf("%d\n", ans);
    }

    return 0;
}