Marriage Match IV

题目

Do not sincere non-interference。 
Like that show, now starvae also take part in a show, but it take place between city A and B. Starvae is in city A and girls are in city B. Every time starvae can get to city B and make a data with a girl he likes. But there are two problems with it, one is starvae must get to B within least time, it's said that he must take a shortest path. Other is no road can be taken more than once. While the city starvae passed away can been taken more than once. 


So, under a good RP, starvae may have many chances to get to city B. But he don't know how many chances at most he can make a data with the girl he likes . Could you help starvae?

Input

The first line is an integer T indicating the case number.(1<=T<=65) 
For each case,there are two integer n and m in the first line ( 2<=n<=1000, 0<=m<=100000 ) ,n is the number of the city and m is the number of the roads. 

Then follows m line ,each line have three integers a,b,c,(1<=a,b<=n,0<c<=1000)it means there is a road from a to b and it's distance is c, while there may have no road from b to a. There may have a road from a to a,but you can ignore it. If there are two roads from a to b, they are different. 

At last is a line with two integer A and B(1<=A,B<=N,A!=B), means the number of city A and city B. 
There may be some blank line between each case.

Output

Output a line with a integer, means the chances starvae can get at most.

样例

Sample Input

3
7 8
1 2 1
1 3 1
2 4 1
3 4 1
4 5 1
4 6 1
5 7 1
6 7 1
1 7

6 7
1 2 1
2 3 1
1 3 3
3 4 1
3 5 1
4 6 1
5 6 1
1 6

2 2
1 2 1
1 2 2
1 2

Sample Output

2
1
1

这道题是参考了kuangbin大佬的模板的

这题就是求从A到B的最短路径的条数。一条边只能经过一次。先通过最短路去除掉没有用的边。然后用一次最大流就是答案了。

从A和B分别出发求最短路dist1,dist2.注意从B求得额时候要反向。如果dist1[a]+dist2[b]+c==dist1[B].那么这条边就是有用的。。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <string.h>
#include <string>
typedef long long ll;
#define INF 0x3f3f3f3f
using namespace std;
#define MAXN 2020
#define MAXM 2000010
struct Node
{
	int to, next, cap;
}edge[MAXM];
int tol;
int head[MAXN];
int gap[MAXN], dis[MAXN], pre[MAXN], cur[MAXN];
void init(){
	tol = 0;
	memset(head, -1, sizeof(head));
}
void addedge(int u, int v, int w, int rw = 0){
	edge[tol].to = v; edge[tol].cap = w; edge[tol].next = head[u]; head[u] = tol++;
	edge[tol].to = u; edge[tol].cap = rw; edge[tol].next = head[v]; head[v] = tol++;
}

int sap(int start, int end, int nodenum){
	memset(dis, 0, sizeof(dis));
	memset(gap, 0, sizeof(gap));
	memcpy(cur, head, sizeof(head));
	int u = pre[start] = start, maxflow = 0, aug = -1;
	gap[0] = nodenum;
	while (dis[start] < nodenum){
	loop:
		for (int& i = cur[u]; i != -1; i = edge[i].next){
			int v = edge[i].to;
			if (edge[i].cap && dis[u] == dis[v] + 1){
				if (aug == -1 || aug > edge[i].cap)
					aug = edge[i].cap;
				pre[v] = u;
				u = v;
				if (v == end){
					maxflow += aug;
					for (u = pre[u]; v != start; v = u, u = pre[u]){
						edge[cur[u]].cap -= aug;
						edge[cur[u] ^ 1].cap += aug;
					}
					aug = -1;
				}
				goto loop;
			}
		}
		int mindis = nodenum;
		for (int i = head[u]; i != -1; i = edge[i].next){
			int v = edge[i].to;
			if (edge[i].cap && mindis > dis[v]){
				cur[u] = i;
				mindis = dis[v];
			}
		}
		if ((--gap[dis[u]]) == 0)break;
		gap[dis[u] = mindis + 1]++;
		u = pre[u];
	}
	return maxflow;
}


int first[MAXN];
bool vis[MAXN];
int cnt[MAXN];
int que[MAXN];
int dist[MAXN];
struct Edge{
	int to, v, next;
}edge1[MAXM];

int tt;
void add(int a, int b, int v){
	edge1[tt].to = b;
	edge1[tt].v = v;
	edge1[tt].next = first[a];
	first[a] = tt++;
}
bool SPFA(int start, int n){
	int front = 0, rear = 0;
	for (int v = 1; v <= n; v++){
		if (v == start){
			que[rear++] = v;
			vis[v] = true;
			cnt[v] = 1;
			dist[v] = 0;
		}
		else{
			vis[v] = false;
			cnt[v] = 0;
			dist[v] = INF;
		}
	}
	while (front != rear){
		int u = que[front++];
		vis[u] = false;
		if (front >= MAXN)front = 0;
		for (int i = first[u]; i != -1; i = edge1[i].next){
			int v = edge1[i].to;
			if (dist[v] > dist[u] + edge1[i].v){
				dist[v] = dist[u] + edge1[i].v;
				if (!vis[v]){
					vis[v] = true;
					que[rear++] = v;
					if (rear >= MAXN)rear = 0;
					if (++cnt[v] > n)return false;
				}
			}
		}
	}
	return true;
}
int a[100010], b[100010], c[100010];
int dist1[MAXN], dist2[MAXN];
int main(){
	int T;
	int n, m;
	scanf("%d", &T);
	while (T--){
		scanf("%d%d", &n, &m);
		int A, B;
		for (int i = 0; i < m; i++)
			scanf("%d%d%d", &a[i], &b[i], &c[i]);
		scanf("%d%d", &A, &B);
		tt = 0;
		memset(first, -1, sizeof(first));
		for (int i = 0; i < m; i++)
			add(a[i], b[i], c[i]);
		SPFA(A, n);
		memcpy(dist1, dist, sizeof(dist));
		tt = 0;
		memset(first, -1, sizeof(first));
		for (int i = 0; i < m; i++)
			add(b[i], a[i], c[i]);
		SPFA(B, n);
		memcpy(dist2, dist, sizeof(dist));
		init();
		for (int i = 0; i < m; i++){
			if (a[i] != b[i] && dist1[a[i]] + dist2[b[i]] + c[i] == dist1[B])
				addedge(a[i], b[i], 1);
		}
		printf("%d\n", sap(A, B, n));
	}
	return 0;
}