hdu6181次短路

Two Paths

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

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

 

Recommend

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 100009;
const int INF = 0x3f3f3f3f;
typedef long long LL;

struct edge
{
    int to, cost;
    edge(int tv = 0, int tc = 0):
        to(tv), cost(tc) {}
};

typedef pair<LL,int> P;
int n, m;
vector<edge> graph[MAXN];

LL dist[MAXN];
LL dist2[MAXN];

void solve()
{
    memset(dist, 0x3f, sizeof(dist));
    memset(dist2, 0x3f, sizeof(dist2));
    priority_queue<P, vector<P>, greater<P> > Q;
    dist[1] = 0ll;
    Q.push(P(0, 1));

    while(!Q.empty())
    {
        P p = Q.top();
        Q.pop();
        int v = p.second;
        LL d = p.first;
        if(dist2[v] < d) continue;
        for(unsigned i = 0; i < graph[v].size(); i++)
        {
            edge &e = graph[v][i];
            LL d2 = d + e.cost;
            if(dist[e.to] > d2)
            {
                swap(dist[e.to], d2);
                Q.push(P(dist[e.to], e.to));
            }
            if(dist2[e.to] > d2 && dist[e.to] <= d2)//次短路可与最短路相同但路径不同dist[e.to] < d2次短路严格小于最短路
            {
                dist2[e.to] = d2;
                Q.push(P(dist2[e.to], e.to));
            }
        }
    }
}

int main()
{
    int A, B, D, t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d", &n, &m);
        for(int i = 1; i <= n; i++) graph[i].clear();
        for(int i = 0; i < m; i++)
        {
            scanf("%d%d%d", &A, &B, &D);
            graph[A].push_back(edge(B, D));
            graph[B].push_back(edge(A, D));
        }
        solve();
        printf("%lld\n",dist2[n]);
    }
    return 0;
}