HDU 6181：Two Paths（次短路）

Two Paths

Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 153428/153428 K (Java/Others)

Total Submission(s): 2184 Accepted Submission(s): 856

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

题意

给出一个无向图，求起点到终点的次短路的长度

思路

按照dijkstra模板，多开一个数组来记录次短路的长度，每次更新完最短路的数值之后，最短路和当前路径交换数值，每次求出当前路径的长度大于最短路的长度并且小于次短路的长度时，更新次短路的长度

最后注意数据范围。

AC代码

/*
* @Author: WZY
* @School: HPU
* @Date:   2018-12-05 17:04:37
* @Last Modified by:   WZY
* @Last Modified time: 2018-12-10 13:40:56
*/
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <math.h>
#include <limits.h>
#include <map>
#include <stack>
#include <queue>
#include <vector>
#include <set>
#include <string>
#define ll long long
#define ull unsigned long long
#define ms(a) memset(a,0,sizeof(a))
#define msf(a) memset(a,INF,sizeof(a))
#define msy(a) memset(a,-1,sizeof(a))
#define pi acos(-1.0)
#define INF 0x7f7f7f7f
#define lson o<<1
#define rson o<<1|1
const double E=exp(1);
const int maxn=1e6+10;
const int mod=1e9+7;
using namespace std;
inline int read()
{
   int X=0,w=1;
   char c=getchar();
   while (c<'0'||c>'9') { if (c=='-') w=-1; c=getchar(); }
   while (c>='0'&&c<='9') X=(X<<3)+(X<<1)+c-'0',c=getchar();
   return X*w;
}
struct wzy
{
   ll Next,to,w;
}edge[maxn];
ll cnt;
ll n,m;
ll head[maxn];
ll dis[maxn];
ll dis1[maxn];
struct node
{
   ll u,d;
   bool operator < (const node& dui) const {return d>dui.d;}
};
inline void add(ll u,ll v,ll w)
{
   edge[cnt].Next=head[u];
   edge[cnt].w=w;
   edge[cnt].to=v;
   head[u]=cnt++;
}
inline void dijkstra()
{
   msf(dis);
   msf(dis1);
   priority_queue<node>q;
   q.push((node){1,0});
   dis[1]=0;
   while(!q.empty())
   {
   	node res=q.top();q.pop();
   	ll u=res.u,d=res.d;
   	for(ll k=head[u];~k;k=edge[k].Next)
   	{
   		ll v=edge[k].to,w=edge[k].w;
   		ll dist=d+w;
   		if(dis[v]>dist)
   		{
   			swap(dist,dis[v]);
   			q.push((node){v,dis[v]});
   		}
   		if(dis1[v]>dist&&dis[v]<dist)
   		{
   			dis1[v]=dist;
   			q.push((node){v,dis1[v]});
   		}
   	}
   }
}
int main(int argc, char const *argv[])
{
   int t;
   scanf("%d",&t);
   while(t--)
   {
   	ll n,m;
   	msy(head);
   	scanf("%lld%lld",&n,&m);
   	ll x,y,z;
   	while(m--)
   	{
   		scanf("%lld%lld%lld",&x,&y,&z);
   		add(x,y,z);
   		add(y,x,z);
   	}
   	dijkstra();
   	printf("%lld\n",dis1[n]);
   }
   return 0;
}