用优先队列优化Dij的一个代码

　　以前看过SPFA的解释，看懂了却一直没有尝试着写出来。今天见到一题100000个点1000000条边的最短路问题，看到边数相对点来说是非常少的，所以我第一反应就是用Dij来做。但是考虑到普通的Dij写这个10^6条边的代码是带不动的，于是我突然想起了好像可以用优先队列来对此优化，这种优化方法叫做SPFA（纠正一下，应该说这种方法跟SPFA类似，但SPFA是对Bellman的普通队列优化）。我没有再去看SPFA的伪代码或者模板，只是凭自己对优先队列的用法来尝试着写这个优先队列优化的Dij，自己算过，理论时间复杂度是O(ke)，e是边的数目，k不超过2。

　　由于是第一次写这个代码，中间出现好多错误，例如，忘记检查队列是否为空而直接用pop和top。

　　最后打完后测试了几组数据，都OK了。于是我就交上去，除了内存开销比较大，时间是相当理想的：

11876kB

30ms

好了，记录一下我的1Y代码吧！

#include "cstdio"
#include "cstdlib"
#include "cstring"
#include "cmath"
#include "cctype"
#include "vector"
#include "set"
#include "map"
#include "string"
#include "algorithm"
#include "stack"
#include "queue"

#define INF 0x7fffffff
#define reset(a) memset(a, 0, sizeof(a))
#define copy(a, b) memcpy(a, b, sizeof(b))
#define PI acos(-1)
#define FMAX (1E300)
#define MAX 1000000000
#define feq(a, b) (fabs((a)-(b))<1E-6)
#define flq(a, b) ((a)<(b)||feq(a, b))
#define MAXN 10005
#define BASE 137
#define PASS puts("pass")
#define filein freopen("test.in", "r", stdin)
#define fileout freopen("test.out", "w", stdout)

using namespace std;

struct Point{
    int p;
    int d;
    bool operator < (const Point &x) const{
        return d > x.d;
    }
};
struct Edge{
    int b;
    int e;
    int d;
    bool operator < (const Edge &x) const{
        return b < x.b;
    }
    bool operator == (const Edge &x) const{
        return b == x.b;
    }
}e[1000000];
priority_queue<Point, vector<Point>, less<Point> >Q;
int v[100001];
bool vis[100001];

int main(){
    int n, m;
    //filein;
    //fileout;
    pair<Edge *, Edge *> p;

    while (~scanf("%d%d", &n, &m)){
        reset(e);
        reset(vis);

        while (Q.size())
            Q.pop();
        vis[1] = true;
        v[1] = 0;
        for (int i = 2; i <= n; i++)
            v[i] = MAX;

        for (int i = 0; i < m; i++)
            scanf("%d%d%d", &e[i].b, &e[i].e, &e[i].d);
        sort(e, e + m);

        int cur = 1;
        Edge te;
        Point tp;

        tp = {1, 0};
        Q.push(tp);
        while (Q.size() && cur != n){
            te.b = cur;
            p = equal_range(e, e + m, te);
            //printf("search  %d  %d\n", p.first - e, p.second - e);
            for (int i = p.first - e, end = p.second - e; i < end; i++){
                if (v[e[i].e] > v[e[i].b] + e[i].d){
                    v[e[i].e] = v[e[i].b] + e[i].d;
                    if (!vis[e[i].e]){
                        tp = {e[i].e, v[e[i].e]};
                        Q.push(tp);
                        //PASS;
                    }
                }
            }
            while (Q.size() && vis[Q.top().p]){
                Q.pop();
            }
            if (Q.size()){
                cur = Q.top().p;
                vis[cur] = true;
                Q.pop();
            }
        }
        printf("%d\n", v[n]);
    }

    return 0;
}

——written by Lyon