手写堆的dijkstra

颓废。。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn=1e5+5, maxm=1e6+5, INF=2147483647;

struct Heap_node{
    int value, id;
    void reset(){
        value=0, id=0;
        return;
    }
};

bool operator< (Heap_node A, Heap_node B){
    if (A.value>B.value) return true;
    else return false;
}

class Heap{
private:
    int pos[maxn];
    Heap_node heap[maxn];

    void exchange(int x, int y){
        pos[heap[x].id]=y;
        pos[heap[y].id]=x;
        swap(heap[x], heap[y]);
    }

    void pushup(int now){
        while (now!=1&&heap[now>>1]<heap[now]){
            exchange(now, now>>1);
            now>>=1;
        }
        return;
    }

    void pushdown(int now){
        bool son1, son2, flag=true;
        while ((now<<1)<=n&&flag){
            flag=false;
            son1=true, son2=true;
            if ((now<<1|1)>n) son2=false;
            if (son2&&heap[now<<1]<heap[now<<1|1]) son1=false;
            else son2=false;
            if (son1&&heap[now]<heap[now<<1]) {
                exchange(now, now<<1);
                now<<=1;
                flag=true;
            }
            if (son2&&heap[now]<heap[now<<1|1]){
                exchange(now, now<<1|1);
                now=now<<1|1;
                flag=true;
            }
        }
        return;
    }

public:
    int n;
    Heap(){
        n=0;
        for (int i=0; i<maxn; ++i) heap[i].reset();
    }

    void push(int num, int id){
        pos[id]=++n;
        heap[n].id=id;
        heap[n].value=num;
        pushup(n);
        return;
    }

    void del(int now){
        pos[heap[n].id]=now;
        pos[heap[now].id]=0;
        heap[now]=heap[n--];
        pushdown(now);
        pushup(now); //
    }

    void delid(int id){
        int now=pos[id];
        del(now);
        return;
    }

    void modify(int value, int id){
        delid(id);
        push(value, id);
        return;
    }

    bool empty(){
        return !n;
    }

    Heap_node top(){
        return heap[1];
    }
};

struct Edge{
    int to, v, next;
};

struct Graph{
    int n, m, cntedge;
    int fir[maxn];
    Edge link[maxn];
    Edge edge[maxm];

    void init(int nodenum, int edgenum){
        n=nodenum, m=edgenum;
    }

    Graph(){
        memset(fir, 0, sizeof(fir));
        memset(edge, 0, sizeof(edge));
        cntedge=0;
        n=0;
        m=0;
        return;
    }

    void addedge(int x, int y, int v){
        ++cntedge;
        edge[cntedge].to=y;
        edge[cntedge].v=v;
        edge[cntedge].next=fir[x];
        fir[x]=cntedge;
        return;
    }

    Edge *get_link(int x){
        int cnt=0;
        for (int nowedge=fir[x]; nowedge;
             nowedge=edge[nowedge].next){
            link[++cnt]=edge[nowedge];
        }
        link[0].v=cnt;
        return link;
    }

};

int n, m, s;
int dis[maxn];
Edge *link;

Heap h;
Graph g;

int main(){
    scanf("%d%d%d", &n, &m, &s);
    g.init(n, m);
    int f, gg, w;
    for (int i=0; i<m; ++i){
        scanf("%d%d%d", &f, &gg, &w);
        g.addedge(f, gg, w);
    }
    for (int i=1; i<=n; ++i){
        dis[i]=INF;
        h.push(INF, i);
    }
    dis[s]=0;
    h.modify(0, s);
    int now, nowson, nowdis;
    while (!h.empty()){
        now=h.top().id;
        h.del(1);
        if (dis[now]==INF) break;
        link=g.get_link(now);
        for (int i=1; i<=link[0].v; ++i){  //注意总共最多访问到2m条边，因此时间复杂度为mlogn
            nowson=link[i].to;
            nowdis=link[i].v;
            if (dis[now]+nowdis<dis[nowson]){
                dis[nowson]=dis[now]+nowdis;
                h.modify(dis[nowson], nowson);
            }
        }
    }
    for (int i=1; i<=n; ++i)
        printf("%d ", dis[i]);
    return 0;
}