Two Paths HDU 次短路问题

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

此题就是求无向图的次短路。即除去最短路以外的最短路，只要走的不一样，可以和最短路一样长。如果只有一条路，那么有一段就得走两遍（就像第二个样例）；

可以说是个板子题，直接套版子；
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
struct mmp {                            
	int to,cost;                
   	mmp(int a,int b) {
		to=a;
		cost=b;
	}
};
ll d1[100001],d2[100001];               //d1为从1到i的最短路，d2为次短路
int m,n;
typedef pair<ll,int> p;                 //用pair对应长度和节点
vector<mmp> mmap[100001];               //用来储存每条路，用动态数组和结构体，节省时间和空间
void solve() {
	priority_queue<p,vector<p>,greater<p> > q;          //用优先队列
	q.push({0,1});                                     
	while(!q.empty()) {
		p now=q.top();
		q.pop();
		int too=now.second;
		ll  d=now.first; 
		if(d>d2[too])                            //若比次短路还长，跳过
			continue;
		for(int i=0; i<mmap[too].size(); i++) {
			ll dd=d+mmap[too][i].cost;
			int to=mmap[too][i].to;
			if(d1[to]>dd) {                 //若此条路比最短路短，交换并压入队列
				swap(dd,d1[to]);
				q.push({d1[to],to});
			}
			if(d2[to]>dd&&dd>d1[to]){      //若此条路比次短路短且比最短路长，与次短路交换位置并压入队列
				swap(dd,d2[to]);
				q.push({d2[to],to});
			}
		}
	}
	cout<<d2[n]<<endl;
}
int main() {
	int t;
	cin>>t;
	while(t--) {
		cin>>n>>m;
		for(int i=1; i<=n; i++) {            //将每条路都设置为无穷大，并清空mmap
			d1[i]=d2[i]=1e18;
			mmap[i].clear();
		}
		for(int i=1; i<=m; i++) {
			int x,y,c;
			cin>>x>>y>>c;
			mmap[x].push_back(mmp(y,c));
			mmap[y].push_back(mmp(x,c));
		}
		solve();
	}
	return 0;
}