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
题意：就是问你最短路的条数有几条
思路：正反djs一下求出最短路线然后建边权为1 的边跑一下网络流即可
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define inf 0x3f3f3f3f
const int maxn = 1009;
struct Edge{
int from, to, cap, flow;
Edge(){}
Edge(int from, int to, int cap, int flow):from(from), to(to), cap(cap), flow(flow){}
};
struct Dinic{
int n, m, s, t;
vector<Edge>edges;
vector<int>G[maxn];
int d[maxn];
int cur[maxn];
int vis[maxn];
void init(int n, int s, int t)
{
this->n = n;this->s = s;this->t = t;
edges.clear();
for(int i = 0;i <= n;++i) G[i].clear();
}
void add_edge(int from, int to, int cap)
{
edges.push_back( Edge(from, to, cap, 0) );
edges.push_back( Edge(to, from, 0, 0) );
m = edges.size();
G[from].push_back(m-2);
G[to].push_back(m-1);
}
bool bfs(){
memset(vis, 0, sizeof(vis));
queue<int>Q;
Q.push(s);
d[s] = 0;
vis[s] = true;
while(!Q.empty())
{
int x = Q.front();
Q.pop();
for(int i = 0;i < G[x].size();++i)
{
Edge& e = edges[G[x][i]];
if(!vis[e.to] && e.cap > e.flow)
{
vis[e.to] = true;
d[e.to] = d[x] + 1;
Q.push(e.to);
}
}
}
return vis[t];
}
int dfs(int x,int a)
{
if(x == t || a == 0)return a;
int flow = 0, f;
for(int& i = cur[x];i < G[x].size();++i)
{
Edge& e = edges[G[x][i]];
if(d[x] + 1 == d[e.to] && (f = dfs( e.to, min(a, e.cap-e.flow)))>0)
{
e.flow += f;
edges[G[x][i]^1].flow -= f;
flow += f;
a -= f;
if(a == 0)break;
}
}
return flow;
}
int maxflow()
{
int flow = 0;
while(bfs())
{
memset(cur, 0, sizeof(cur));
flow += dfs(s,inf);
}
return flow;
}
}solve;//刘汝佳网络流dinic板子
struct Edge1
{
int from, to; ll dist; //起点,终点,距离
Edge1(int from, int to, ll dist):from(from), to(to), dist(dist) {}
};
int n,m;
struct Dijkstra
{
int n, m; //结点数,边数(包括反向弧)
vector<Edge1> edges; //边表。edges[e]和edges[e^1]互为反向弧
vector<int> G[maxn]; //邻接表，G[i][j]表示结点i的第j条边在edges数组中的序号
int vis[maxn]; //标记数组
ll d[maxn]; //s到各个点的最短路
int p[maxn]; //上一条弧
void init(int n)
{
this->n = n;
edges.clear();
for (int i = 0; i <= n; i++) G[i].clear();
}
void AddEdge(int from, int to, int dist)
{
edges.push_back(Edge1(from, to, dist));
m = edges.size();
G[from].push_back(m - 1);
}
struct HeapNode
{
int from; ll dist;
bool operator < (const HeapNode& rhs) const
{
return rhs.dist < dist;
}
HeapNode(int u, ll w): from(u), dist(w) {}
};
void dijkstra(int s)
{
priority_queue<HeapNode> Q;
for (int i = 0; i <= n; i++) d[i] = inf;
memset(vis, 0, sizeof(vis));
d[s] = 0;
Q.push(HeapNode(s, 0));
while (!Q.empty())
{
HeapNode x = Q.top(); Q.pop();
int u = x.from;
if (vis[u]) continue;
vis[u] = true;
for (int i = 0; i < G[u].size(); i++)
{
Edge1& e = edges[G[u][i]];
if (d[e.to] > d[u] + e.dist)
{
d[e.to] = d[u] + e.dist;
p[e.to] = G[u][i];
Q.push(HeapNode(e.to, d[e.to]));
}
}
}
}
// void output(int x)
// {
// if (x == 1)
// {
// printf("%d", x);
// return ;
// }
// output(edges[p[x]].from);
// printf(" %d", x);
// putchar('\n');
// }
}gao1, gao2;
struct node{
int from, to, dist;
}edgeall[100009];
int main()
{
int t;
scanf("%d", &t);
while(t--) {
scanf("%d%d", &n, &m);
gao1.init(n);gao2.init(n);
int cn = 0;
for(int i = 1;i <= m;++i) {
int x, y, step;
scanf("%d%d%d", &x, &y, &step);
gao1.AddEdge(x, y, step);
gao2.AddEdge(y, x, step);
edgeall[cn].from = x;
edgeall[cn].to = y;
edgeall[cn].dist = step;
cn++;
}
int start, end;
scanf("%d%d", &start, &end);
gao1.dijkstra(start);
ll ans = gao1.d[end];
gao2.dijkstra(end);
solve.init(n, start, end);
for(int i = 0;i < m;++i) {
if(gao1.d[edgeall[i].from] + edgeall[i].dist + gao2.d[edgeall[i].to] == ans) {
solve.add_edge(edgeall[i].from, edgeall[i].to, 1);
}
}
ll anss = solve.maxflow();
printf("%lld\n", anss);
}
return 0;
}