poj3463最短路和次短路计数

题目链接

Description

Tour operator Your Personal Holiday organises guided bus trips across the Benelux. Every day the bus moves from one city S to another city F. On this way, the tourists in the bus can see the sights alongside the route travelled. Moreover, the bus makes a number of stops (zero or more) at some beautiful cities, where the tourists get out to see the local sights.

Different groups of tourists may have different preferences for the sights they want to see, and thus for the route to be taken from S to F. Therefore, Your Personal Holiday wants to offer its clients a choice from many different routes. As hotels have been booked in advance, the starting city S and the final city F, though, are fixed. Two routes from S to F are considered different if there is at least one road from a city A to a city B which is part of one route, but not of the other route.

There is a restriction on the routes that the tourists may choose from. To leave enough time for the sightseeing at the stops (and to avoid using too much fuel), the bus has to take a short route from S to F. It has to be either a route with minimal distance, or a route which is one distance unit longer than the minimal distance. Indeed, by allowing routes that are one distance unit longer, the tourists may have more choice than by restricting them to exactly the minimal routes. This enhances the impression of a personal holiday.

For example, for the above road map, there are two minimal routes from S = 1 to F = 5: 1 → 2 → 5 and 1 → 3 → 5, both of length 6. There is one route that is one distance unit longer: 1 → 3 → 4 → 5, of length 7.

Now, given a (partial) road map of the Benelux and two cities S and F, tour operator Your Personal Holiday likes to know how many different routes it can offer to its clients, under the above restriction on the route length.

Input

The first line of the input file contains a single number: the number of test cases to follow. Each test case has the following format:

One line with two integers N and M, separated by a single space, with 2 ≤ N ≤ 1,000 and 1 ≤ M ≤ 10, 000: the number of cities and the number of roads in the road map.

M lines, each with three integers A, B and L, separated by single spaces, with 1 ≤ A, B ≤ N, A ≠ B and 1 ≤ L ≤ 1,000, describing a road from city A to city B with length L.

The roads are unidirectional. Hence, if there is a road from A to B, then there is not necessarily also a road from B to A. There may be different roads from a city A to a city B.

One line with two integers S and F, separated by a single space, with 1 ≤ S, F ≤ N and S ≠ F: the starting city and the final city of the route.

There will be at least one route from S to F.

Output

For every test case in the input file, the output should contain a single number, on a single line: the number of routes of minimal length or one distance unit longer. Test cases are such, that this number is at most 109 = 1,000,000,000.

Sample Input

2
5 8
1 2 3
1 3 2
1 4 5
2 3 1
2 5 3
3 4 2
3 5 4
4 5 3
1 5
5 6
2 3 1
3 2 1
3 1 10
4 5 2
5 2 7
5 2 7
4 1
Sample Output

3
2

题意：这道题就是让你求出有向图中最短路和比最短路长1的路的数量， 我们求出次短路和最短路的数量即可解决这道题。
　dij算法，可以将最短路与次短路看成两种独立的状态。
　
对于如果距离相同，只是更新数量为什么不用入堆？因为dij保证了当前出堆的一定是最小距离，而v点既然不是inf，则此时v点一定在堆中

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#include<vector>
using namespace std;
typedef pair<int,int> PII;
const int inf = 0x3f3f3f3f;
const int N = 1005;
const int M = 10005;
int T;
int n,m;
struct edge{
	int v,ne,w;
}e[M];

struct Node{
	int dis,id,type;
	bool operator < (const Node & a) const {
		return dis>a.dis;
	} 
};

int h[N],idx,vis[N][2];
int d[N][2],cnt[N][2];
//d[i][0]表示最短路的长度，cnt[i][0]表示最短路的数量 

void add(int a,int b,int c){
	e[idx].v = b;
	e[idx].w = c;
	e[idx].ne = h[a];
	h[a] = idx++;
} 

void dij(int x){
	int i,j;
	memset(vis,0,sizeof vis);
	memset(cnt,0,sizeof cnt);
	cnt[x][0] = 1;
	memset(d,0x3f,sizeof d);
	d[x][0] = 0; 
	priority_queue<Node> q;
	q.push((Node){d[x][0],x,0});
	while(!q.empty()){
		Node t = q.top();q.pop();
		int x = t.id,y = t.type;
		if(vis[x][y])	continue;
		vis[x][y] = 1;
		for(i = h[x];i!=-1;i=e[i].ne){
			int v = e[i].v,w = e[i].w;
			//处理最小距离和次小距离和数量
			if(y == 0){
			    //两个y可以合并
				if(d[v][0] > d[x][y] + w){
					d[v][1] = d[v][0];
					cnt[v][1] = cnt[v][0];
					d[v][0] = d[x][y] + w;
					cnt[v][0] = cnt[x][y];
					q.push((Node){d[v][0],v,0});
					q.push((Node){d[v][1],v,1});
				}else if(d[v][0] == d[x][y] + w){
					cnt[v][0] += cnt[x][y];
				//	q.push((Node){d[v][y],v,y});
				//相等的话不需要入堆，因为dij保证了当前出堆的一定是最小距离，而v点既然不是inf，则此时v点一定在堆中 
				}else if(d[v][1] > d[x][y] + w){
					d[v][1] = d[x][y] + w;
					cnt[v][1] = cnt[x][y];
					q.push((Node){d[v][1],v,1});
				}else if(d[v][1] == d[x][y] + w){
					cnt[v][1] += cnt[x][y];
				}
			}
		
			if(y == 1){
			    //如果为次小距离则一定只能更次小距离
				if(d[v][1] > d[x][1] + w){
					//如果比最小距离大，比次小距离小 
					d[v][1] = d[x][1] + w;
					cnt[v][1] = cnt[x][1];
					q.push((Node){d[v][1],v,1});
				}else if(d[v][1] == d[x][1] + w){
					cnt[v][1] += cnt[x][1];
				}
			}
		}
	}
}

int main(){
	int i,j;
	cin>>T;
	while(T--){
		memset(h,-1,sizeof h);
		idx = 0; 
		cin>>n>>m;
		for(i = 1;i<=m;i++){
			int a,b,c;
			cin>>a>>b>>c;
			add(a,b,c);
		}
		int startx,endx;
		cin>>startx>>endx;
		//dij
		dij(startx);
		if(d[endx][0] +1 == d[endx][1]){
		    cout<<cnt[endx][0]+cnt[endx][1]<<endl;
		}
	    else
	        cout<<cnt[endx][0]<<endl;
	}
	return 0;
}