Invitation Cards【最短路】

 

题目大意：

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

 

解题思路：

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

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

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

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

总结就是：

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

 

代码如下：

 

[cpp] view plaincopyprint?
  1. #include<iostream>  
  2. #include<cstdio>  
  3. #include<climits>  
  4. #include<cstring>  
  5. #include<queue>  
  6. #include<cmath>  
  7. usingnamespace std; 
  8.  
  9. #define CLR(arr, what) memset(arr, what, sizeof(arr))  
  10. constint N = 1000010; 
  11. constlonglong MAX = 10000000000000005; //数据太大。10亿*100W  
  12.  
  13. int Head[N], Next[N], Key[N], Num[N], num; 
  14. longlong 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. longlong SPFA(int start) 
  41. { 
  42.     longlong total = 0; 
  43.     int temp; 
  44.     queue<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.     longlong 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. } 
posted @ 2012-11-10 14:17  燕笑语兮  阅读(206)  评论(0)  编辑  收藏  举报