最短路

问题描述

给定一个n个顶点，m条边的有向图（其中某些边权可能为负，但保证没有负环）。请你计算从1号点到其他点的最短路（顶点从1到n编号）。

输入格式

第一行两个整数n, m。

接下来的m行，每行有三个整数u, v, l，表示u到v有一条长度为l的边。

输出格式

共n-1行，第i行表示1号点到i+1号点的最短路。

样例输入

3 3
1 2 -1
2 3 -1
3 1 2

样例输出

-1
-2

数据规模与约定

对于10%的数据，n = 2，m = 2。

对于30%的数据，n <= 5，m <= 10。

对于100%的数据，1 <= n <= 20000，1 <= m <= 200000，-10000 <= l <= 10000，保证从任意顶点都能到达其他所有顶点。

今天犯了几个十分低级的错误。

在双重循环里面用了同一个循环变量。

在开始用堆做这个题的时候卡了一会，不知道如何在堆中能直接索引元素，后来想到堆中只放数组下标，然后问题基本解决。

之后就是痛苦的Debug过程，因为堆中只有数组下标，所以堆排序的操作复杂到必然出错，结果花了几个小时才理清头绪。

又学了一遍堆排序，但总是记不住，不知道还要学几次。。。

1. #include<stdio.h>
2. #include<string.h>
3. #include<stdlib.h>
5. #define N 20020
6. #define INF 2147483640
8. typedef struct Node
9. {
10.     int v;
11.     int d;
12.     struct Node *next;
13. } Node, *Np;
15. Np list[N];
17. void insert(int a, int b, int c)
18. {
19.     Np np = malloc(sizeof(Node));
20.     np->d = b;
21.     np->v = c;
22.     np->next = list[a];
23.     list[a] = np;
24. }
26. typedef struct Data
27. {
28.     int v;
29.     int rp;
30. }Data;
32. Data data[N];
33. int heap[N];
35. void swap(int a, int b)
36. {
37.     int t = heap[a];
38.     heap[a] = heap[b];
39.     heap[b] = t;
40.     data[heap[a]].rp = a;
41.     data[heap[b]].rp = b;
42. }
44. void up(int x)
45. {
46.     while(x > 1)
47.     {
48.         if(data[heap[x / 2]].v > data[heap[x]].v)
49.         {
50.             swap(x, x / 2);
51.             x /= 2;
52.         }
53.         else
54.         {
55.             break;
56.         }
57.     }
58. }
60. void down(int x, int len)
61. {
62.     while(x * 2 <= len)
63.     {
64.         int a = x * 2;
65.         if(a + 1 <= len && data[heap[a]].v > data[heap[a + 1]].v)
66.         {
67.             a = a + 1;
68.         }
69.         if(data[heap[x]].v > data[heap[a]].v)
70.         {
71.             swap(x, a);
72.             x = a;
73.         }
74.         else
75.         {
76.             break;
77.         }
78.     }
79. }
81. int main(void)
82. {
83.     int i, n, m;
84.     scanf("%d%d", &n, &m);
85.     for(i = 0; i < m; i++)
86.     {
87.         int a, b, c;
88.         scanf("%d%d%d", &a, &b, &c);
89.         insert(a, b, c);
90.     }
91.     for(i = 2; i <= n; i++)
92.     {
93.         heap[i - 1] = i;
94.         data[i].v = INF;
95.         data[i].rp = i - 1;
96.     }
97.     Np p = list[1];
98.     while(p != NULL)
99.     {
100.         data[p->d].v = p->v;
101.         up(data[p->d].rp);
102.         p = p->next;
103.     }
104.     int count = n - 1;
105.     while(count > 1)
106.     {
107.         int base = heap[1];
108.         swap(1, count--);
109.         down(1, count);
110.         Np p = list[base];
111.         while(p != NULL)
112.         {
113.             int t = p->v + data[base].v;
114.             if(t < data[p->d].v)
115.             {
116.                 data[p->d].v = t;
117.                 up(data[p->d].rp);
118.             }
119.             Np temp = p;
120.             p = p->next;
121.             free(temp);
122.         }
123.     }
124.     for(i = 2; i <= n; i++)
125.     {
126.         printf("%d\n", data[i].v);
127.     }
128.     return 0;
129. }