Roadblocks(POJ 3255)

• 原题如下：
  Roadblocks

  Time Limit: 2000MS		Memory Limit: 65536K
  Total Submissions: 19314		Accepted: 6777

  Description

  Bessie has moved to a small farm and sometimes enjoys returning to visit one of her best friends. She does not want to get to her old home too quickly, because she likes the scenery along the way. She has decided to take the second-shortest rather than the shortest path. She knows there must be some second-shortest path.

  The countryside consists of R (1 ≤ R ≤ 100,000) bidirectional roads, each linking two of the N (1 ≤ N ≤ 5000) intersections, conveniently numbered 1..N. Bessie starts at intersection 1, and her friend (the destination) is at intersection N.

  The second-shortest path may share roads with any of the shortest paths, and it may backtrack i.e., use the same road or intersection more than once. The second-shortest path is the shortest path whose length is longer than the shortest path(s) (i.e., if two or more shortest paths exist, the second-shortest path is the one whose length is longer than those but no longer than any other path).

  Input

  Line 1: Two space-separated integers: N and R 
  Lines 2..R+1: Each line contains three space-separated integers: A, B, and D that describe a road that connects intersections A and B and has length D (1 ≤ D ≤ 5000)

  Output

  Line 1: The length of the second shortest path between node 1 and node N

  Sample Input

  4 4
  1 2 100
  2 4 200
  2 3 250
  3 4 100

  Sample Output

  450

  Hint

  Two routes: 1 -> 2 -> 4 (length 100+200=300) and 1 -> 2 -> 3 -> 4 (length 100+250+100=450)
• 题解：这题要求的是次短路，根据Dijkstra算法的思路，依次确定尚未确定的顶点中距离最小的顶点可求得最短路，在这个基础上做少许修改，即可求得次短路，到某个顶点v的次短路无非两种情况：①到其它顶点u的最短路再加上u→v的边，②到u的次短路再加上u→v的边。因此，只要求出到所有顶点的最短路和次短路就好了。对于每个顶点，我们记录最短路和次短路，类似Dijkstra算法那样，不断更新这两个距离。（注：这道题中男女之间的二分图结构是无用的陷阱条件，许多问题中，如果有特殊的结构，往往会考虑如何利用这个结构，但这题不是的）
• 代码：

   #include <cstdio>
   #include <queue>
   #include <vector>
   #include <functional>
   #include <cctype>
   #include <algorithm>
   #define num s-'0'
  
   using namespace std;
   typedef pair<int, int> P;
  
   struct edge
   {
       int to;
       int cost;
   };
  
   const int MAX_V=;
   const int INF=0x3f3f3f3f;
   int V,E,n;
   vector<edge> G[MAX_V];
   int dist[MAX_V];
   int dist2[MAX_V];
  
   void solve();
  
   void swap(int &x, int &y)
   {
       int t=x;
       x=y;y=t;
   }
  
   void read(int &x){
       char s;
       x=;
       bool flag=;
       while(!isdigit(s=getchar()))
           (s=='-')&&(flag=true);
       for(x=num;isdigit(s=getchar());x=x*+num);
       (flag)&&(x=-x);
   }
  
   void write(int x)
   {
       if(x<)
       {
           putchar('-');
           x=-x;
       }
       if(x>)
           write(x/);
       putchar(x%+'');
   }
  
   int main()
   {
       read(V);read(E);
       for (int i=; i<E; i++)
       {
           edge e;
           int s,t,c;
           read(s);read(t);read(c);
           e.to=t-;e.cost=c;
           G[s-].push_back(e);
           e.to=s-;e.cost=c;
           G[t-].push_back(e);
       }
       solve();
       write(dist2[V-]);
       putchar('\n');
   }
  
   void solve()
   {
       priority_queue<P, vector<P>, greater<P> > que;
       fill(dist, dist+V, INF);
       fill(dist2, dist2+V, INF);
       dist[]=;
       que.push(P(,));
       while (!que.empty())
       {
           P p=que.top(); que.pop();
           int v=p.second, d=p.first;
           if (dist2[v]<d) continue;
           for (int i=; i<G[v].size(); i++)
           {
               edge &e=G[v][i];
               int d2=d+e.cost;
               if (dist[e.to]>d2)
               {
                   swap(dist[e.to],d2);
                   que.push(P(dist[e.to],e.to));
               }
               if (dist2[e.to]>d2 && dist[e.to]<d2)
               {
                   dist2[e.to]=d2;
                   que.push(P(dist2[e.to],e.to));
               }
           }
       }
   }