HDU 6181 Two Paths (次短路)

Two Paths

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 153428/153428 K (Java/Others)
Total Submission(s): 5    Accepted Submission(s): 2

Problem Description

You are given a undirected graph with n nodes (numbered from 1 to n) and m edges. Alice and Bob are now trying to play a game. 
Both of them will take different route from 1 to n (not necessary simple).
Alice always moves first and she is so clever that take one of the shortest path from 1 to n.
Now is the Bob's turn. Help Bob to take possible shortest route from 1 to n.
There's neither multiple edges nor self-loops.
Two paths S and T are considered different if and only if there is an integer i, so that the i-th edge of S is not the same as the i-th edge of T or one of them doesn't exist.

 

Input

The first line of input contains an integer T(1 <= T <= 15), the number of test cases.
The first line of each test case contains 2 integers n, m (2 <= n, m <= 100000), number of nodes and number of edges. Each of the next m lines contains 3 integers a, b, w (1 <= a, b <= n, 1 <= w <= 1000000000), this means that there's an edge between node a and node b and its length is w.
It is guaranteed that there is at least one path from 1 to n.
Sum of n over all test cases is less than 250000 and sum of m over all test cases is less than 350000.

 

Output

For each test case print length of valid shortest path in one line.

 

Sample Input

  
  

   
   2
3 3
1 2 1
2 3 4
1 3 3
2 1
1 2 1
  
  

 

Sample Output

  
  

   
   5
3

   
   

    
    

     
     Hint
    
    
For testcase 1, Alice take path 1 - 3 and its length is 3, and then Bob will take path 1 - 2 - 3 and its length is 5.
For testcase 2, Bob will take route 1 - 2 - 1 - 2  and its length is 3

   
   
   
    
  
  

 

Source

2017 Multi-University Training Contest - Team 10 

 

次短路裸题

本以为是次短路裸题，其实是数据太水了，最短路有两条以上的话即取最短路。

#include <iostream>
#include <stdio.h>
#include <queue>
#include <vector>//again
using namespace std;
#define  LL long long
const LL N = 100000+6;
const LL inf = 1000000000100100;
typedef pair<LL,LL> p;
struct edge
{
    LL v,w;
    edge(LL x,LL y):
    v(x),w(y){}
};
vector<edge>G[N];
vector<edge>len;
LL n,m,d[N],d2[N];
int num=0;
void djtsl()
{
    priority_queue<p,vector<p>,greater<p>> q;
    for(LL i=1;i<=n;i++) d[i]=inf,d2[i]=inf;
    d[1]=0;
    q.push(p(d[1],1));
    while(!q.empty())
    {
        LL now=q.top().first;
        LL u=q.top().second;
        q.pop();
        if(d2[u]<now) continue;
        for(LL i=0;i<G[u].size();i++)
        {
            LL v=G[u][i].v;
            LL w=G[u][i].w;
            LL len=now+w;
            if(d[v]>len)
            {
                swap(len, d[v]);
                q.push(p(d[v],v));
            }
            if(d[v]==len&&v==n)
                num++;
            if(d2[v]>len&&d[v]<len)
            {
                d2[v]=len;
                q.push(p(d2[v],v));
                
            }
        }
    }
    if(num>=1) printf("%lld\n",d[n]);
    else printf("%lld\n",d2[n]);
    
}
void add(LL u,LL v,LL w)
{
    G[u].push_back(edge(v,w));
    G[v].push_back(edge(u,w));
}
void init()
{
    for(LL i=0;i<N;i++) G[i].clear();
    len.clear();
}
int main()
{
    LL T;
    scanf("%lld",&T);
    while(T--)
    {
        scanf("%lld %lld",&n,&m);
        init();
        for(LL i=1;i<=m;i++)
        {
            LL u,v,w;
            scanf("%lld %lld %lld",&u,&v,&w);
            add(u,v,w);
        }
        djtsl();
    }
}