poj 1511 spfa算法_codestorm_新浪博客

转自：http://blog.youkuaiyun.com/niushuai666/article/details/7322508

题目大意：

给你一个N个点的图，求1点到其他每个点最短路权值之和sum1，然后再求反向最短路（其他所有点到1点最短距离）之和sum2。输出sum1+sum2

解题思路：

别人说的题意，正好最短路也忘了，就用SPFA写了一下。结果SPFA忘了。。。问了别人，算是懂了。

所谓的SPFA，就是bellman-ford的优化，因为bellman-ford是循环更新每条边n-1次（循环次数固定），但是效率很低，因为不可能每条边都需要更新这么多次吧。所以，出现了SPFA。SPFA的改进之处在于，我加入队列的元素都是已经松弛过，最短距离减小的点，我每次取出对头，更新所以经过这个节点的其他点，如果其他节点的最短距离通过这个队头的点能变小，就松弛。不能就遍历其他点。这样，更新的次数大大减少。

之前我的SPFA是用邻接矩阵实现的，效率之挫就不多说了，因为没有充分利用邻接表的优势，因为邻接矩阵我必须逐个遍历，才能知道两点之间是否存在边，而邻接表存储的就是两点之间相连的边。

这样，SPFA+邻接表的组合就变得更加强大。。。。

总结就是：

最短路题目，最好都使用邻接表+SPFA。这样，差不多就能解决了。（除非特别出数据专门卡SPFA！~~还没遇到~~~~）

代码如下：

 

[cpp]  view plain copy

1. #include  
2. #include  
3. #include  
4. #include  
5. #include  
6. #include  
7. using namespace std;  
8.   
9. #define CLR(arr, what) memset(arr, what, sizeof(arr))  
10. const int N = 1000010;  
11. const long long MAX = 10000000000000005; //数据太大。10亿*100W  
12.   
13. int Head[N], Next[N], Key[N], Num[N], num;  
14. long long dis[N];  
15. bool visit[N];  
16. int nodenum, edgenum;  
17.   
18. struct Edge //结构体存图，方便反向建边  
19. {  
20.     int u, v;  
21.     int weight;  
22. }edge[N];  
23.   
24. void add(int u, int v, int cost) //u,v之间加入权值为cost的边  
25. {  
26.     Key[num] = cost;  
27.     Next[num] = Head[u];  
28.     Num[num] = v;  
29.     Head[u] = num++;  
30. }  
31.   
32. void init()  
33. {  
34.     num = 0;  
35.     CLR(Head, -1);  
36.     for(int i = 1; i <= nodenum; ++i)  
37.         dis[i] = MAX;  
38. }  
39.   
40. long long SPFA(int start)  
41. {  
42.     long long total = 0;  
43.     int temp;  
44.     queue<<span class="datatypes" style="margin: 0px; padding: 0px; border: none; color: rgb(46, 139, 87); background-color: inherit; font-weight: bold;">int> q;  
45.     while(!q.empty())  
46.         q.pop();  
47.     CLR(visit, false);  
48.   
49.     dis[start] = 0;  
50.     visit[start] = true;  
51.   
52.     q.push(start);  
53.     while(!q.empty())  
54.     {  
55.         temp = q.front();  
56.         q.pop();  
57.         visit[temp] = false;  
58.         for(int i = Head[temp]; i != -1; i = Next[i]) //邻接表实现  
59.         {  
60.             if(dis[Num[i]] > dis[temp] + Key[i])  
61.             {  
62.                 dis[Num[i]] = dis[temp] + Key[i];  
63.                 if(!visit[Num[i]])  
64.                 {  
65.                     q.push(Num[i]);  
66.                     visit[Num[i]] = true;  
67.                 }  
68.             }  
69.         }  
70.     }  
71.     for(int i = 1; i <= nodenum; ++i)  
72.         total += dis[i];  
73.     return total;  
74. }  
75.   
76. int main()  
77. {  
78.     int ncase;  
79.     int top;  
80.     long long answer;  
81.     scanf("%d", &ncase);  
82.     while(ncase--)  
83.     {  
84.         top = answer = 0;  
85.         scanf("%d%d", &nodenum, &edgenum);  
86.         init();  
87.         for(int i = 0; i < edgenum; ++i)  
88.         {  
89.             scanf("%d %d %d", &edge[top].u, &edge[top].v, &edge[top].weight);  
90.             add(edge[top].u, edge[top].v, edge[top].weight);  
91.             top++;  
92.         }  
93.         answer += SPFA(1);  
94.         init();  
95.         for(int i = 0; i < top; ++i) //反向图  
96.             add(edge[i].v, edge[i].u, edge[i].weight);  
97.         answer += SPFA(1);  
98.         printf("%lld\n", answer);  
99.     }  
100.     return 0;  
101. }