手写堆的dijkstra

颓废。。

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

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

 struct Heap_node{
     int value, id;
     void reset(){
         value=, id=;
         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!=&&heap[now>>]<heap[now]){
             exchange(now, now>>);
             now>>=;
         }
         return;
     }

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

 public:
     int n;
     Heap(){
         n=;
         for (int i=; 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]=;
         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[];
     }
 };

 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, , sizeof(fir));
         memset(edge, , sizeof(edge));
         cntedge=;
         n=;
         m=;
         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=;
         for (int nowedge=fir[x]; nowedge;
              nowedge=edge[nowedge].next){
             link[++cnt]=edge[nowedge];
         }
         link[].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=; i<m; ++i){
         scanf("%d%d%d", &f, &gg, &w);
         g.addedge(f, gg, w);
     }
     for (int i=; i<=n; ++i){
         dis[i]=INF;
         h.push(INF, i);
     }
     dis[s]=;
     h.modify(, s);
     int now, nowson, nowdis;
     while (!h.empty()){
         now=h.top().id;
         h.del();
         if (dis[now]==INF) break;
         link=g.get_link(now);
         for (int i=; i<=link[].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=; i<=n; ++i)
         printf("%d ", dis[i]);
     return ;
 }