poj 3159 heap+dijkstra

思路：仔细看题，其实就是求1点到n点的最短路，图是有向的，时间卡的比较严，要用静态内存

 

1. #include <iostream>
2. #include <algorithm>
3. using namespace std;
5. const int N = 31000, M = 2500000, INF = 1000000000;
7. #define left(x) ((x)<<1)
8. #define right(x) (((x)<<1)+1)
9. #define dad(x) ((x)>>1)
11. struct data
12. {
13.     int id, w;
14.     data *next;
15. }mem[M];
17. int mem_size, size, n, m;
18. typedef data * node;
19. node g[N];
21. int dist[N], heap[3*N], map[N];
23. node new_node(int id, int w)
24. {
25.     mem[mem_size++] = (data){id,w,0};
26.     return mem+mem_size-1;
27. }
31. void heap_up(int root)
32. {
33.     int t=heap[root], fa=dad(root);
34.     // hint: t = heap[root], not t = root
35.     while(root!=1 && dist[t] < dist[heap[fa]])
36.     {
37.         heap[root] = heap[fa];
38.         map[heap[root]] = root;
39.         root = fa;
40.         fa = dad(root);
41.     }
42.     heap[root] = t;
43.     map[heap[root]] = root;
44. }
46. void heap_down(int root)
47. {
48.     int pos, t=heap[root], rc;
49.     while((pos=left(root)) <= size)
50.     {
51.         rc = right(root);
52.         if(rc <= size && dist[heap[rc]] < dist[heap[pos]]) pos  = rc;
53.         if(dist[t] > dist[heap[pos]] )
54.         {
55.             heap[root] = heap[pos];
56.             map[heap[root]] = root;
57.         }
58.         else break;
59.         root = pos;
60.     }
61.     heap[root] = t;
62.     map[heap[root]] = root;
63. }
65. int heap_pop()
66. {
67.     int t=heap[1];
68.     heap[1]=heap[size--];
69.     map[heap[1]] = 1;
70.     heap_down(1);
71.     return t;
72. }
74. int dijkstra(int s, int t)
75. {
76.     int i, j, k, u, v, tmp;
77.     node p;
78.     for(i = 1; i <= n; i++)
79.     {
80.         dist[i] = INF;
81.         heap[i] = i;
82.         map[i] = i;
83.     }
84.     size = n;
85.     swap(heap[1],heap[s]);
86.     swap(map[1],map[s]);
87.     dist[s] = 0;
89.     for(i = 1; i <= n; i++)
90.     {
91.         u = heap_pop();
92.         for(p = g[u]->next; p; p = p->next)
93.         {
94.             j = dist[u] + p->w;
95.             v = p->id;
96.             if(j < dist[v])
97.             {
98.                 dist[v] = j;
99.                 heap_up(map[v]);
100.             }
101.         }
102.     }
104.     return dist[t];
105. }
107. int main()
108. {
109.     int i, j, id, w;
110.     node tmp;
111.     scanf("%d%d", &n, &m);
113.     mem_size=0;
114.     size=0;
115.     for(i = 1; i <= n; i++) g[i]= new_node(0,0);
116.     // clear heap, map, dist, size if multiple tests
119.     for(i = 0; i < m; i++)
120.     {
121.         scanf("%d%d%d",&j,&id,&w);
122.         tmp = g[j]->next;
123.         g[j]->next = new_node(id,w);
124.         g[j]->next->next = tmp;
125.     }
127.     printf("%d/n", dijkstra(1, n));
128.     return 0;
129. }