Marriage Match IV HDU3461 网络流+最短路spfa

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

题解：

本题目的实质就是最短路径计数，但是有一点需要强调的一点就是，这里的边不能重复走，否则的话，跑完spfa，一遍dfs就ok了。

在这里要求边不能走重复，所以说，我们就要用网络流的方法来做了。重点是怎么建图。

我们先用spfa求一下起点到所有点的最短路。

然后进行dfs建边，建边的时候，但d[v] == d[u] + cost的时候，表明这条边有可能构成最短路的一条路径，那么就从u向v连接一条容量为1的边。

（这里千万要注意的一点就是，走过的边要打标记，不要重复走，否则会陷入死循环）

边建立完成以后，跑一个从起点到终点的网络流就好了

代码：

#include<cstdio>#include<iostream>#include <cstring>#include <queue> using namespace std;const int oo=1e9;/**oo 表示无穷大*/const int mm=200007;/**mm 表示边的最大数量，记住要是原图的两倍，在加边的时候都是双向的*/const int mn=1007;/**mn 表示点的最大数量*/int node,src,dest,edge;/**node 表示节点数，src 表示源点，dest 表示汇点，edge 统计边数*/int ver[mm],flow[mm],nxt[mm];/**ver 边指向的节点，flow 边的容量，nxt 链表的下一条边*/int head[mn],work[mn],dis[mn],q[mn];/**head 节点的链表头，work 用于算法中的临时链表头，dis 计算距离*//**初始化链表及图的信息*/void prepare(int _node,int _src,int _dest){    node=_node,src=_src,dest=_dest;    memset(head,-1,sizeof(head));    edge=0;}/**增加一条u 到v 容量为c 的边*/void addedge(int u,int v,int c){    ver[edge]=v,flow[edge]=c,nxt[edge]=head[u],head[u]=edge++;    ver[edge]=u,flow[edge]=0,nxt[edge]=head[v],head[v]=edge++;}/**广搜计算出每个点与源点的最短距离，如果不能到达汇点说明算法结束*/bool Dinic_bfs(){    int i,u,v,l,r=0;    for(i=0; i<node; ++i)dis[i]=-1;    dis[q[r++]=src]=0;    for(l=0; l<r; ++l)        for(i=head[u=q[l]]; i>=0; i=nxt[i])            if(flow[i]&&dis[v=ver[i]]<0)            {                /**这条边必须有剩余容量*/                dis[q[r++]=v]=dis[u]+1;                if(v==dest)return 1;            }    return 0;}/**寻找可行流的增广路算法，按节点的距离来找，加快速度*/int Dinic_dfs(int u,int exp){    if(u==dest)return exp;    /**work 是临时链表头，这里用i 引用它，这样寻找过的边不再寻找*/    for(int &i=work[u],v,tmp; i>=0; i=nxt[i])        if(flow[i]&&dis[v=ver[i]]==dis[u]+1&&(tmp=Dinic_dfs(v,min(exp,flow[i])))>0)        {            flow[i]-=tmp;            flow[i^1]+=tmp;            /**正反向边容量改变*/            return tmp;        }    return 0;}int Dinic_flow(){    int i,ret=0,delta;    while(Dinic_bfs())    {        for(i=0; i<node; ++i)work[i]=head[i];        while(delta=Dinic_dfs(src,oo))ret+=delta;    }    return ret;}const int MAXN = 1007;int heads[MAXN];int cnt;struct edge{     int v;     int nxt;     int cost; }Es[200007];  int d[MAXN];void init(){     cnt = 0;     memset(heads,-1,sizeof(heads)); }inline void add_edge(int i,int j,int cost){       Es[cnt].v = j;     Es[cnt].cost = cost;     Es[cnt].nxt = heads[i];     heads[i] = cnt++; }   void spfa(int x){memset(d,0x3f,sizeof(d));int instack[MAXN];memset(instack,0,sizeof(instack));d[x] = 0;queue<int> Q;Q.push(x);instack[x] = 1;while(!Q.empty()){int u = Q.front();Q.pop();for(int e = heads[u];e != -1;e = Es[e].nxt){int v = Es[e].v;int cost = Es[e].cost;if(d[v] > d[u] + cost){d[v] = d[u] + cost; if(!instack[v]){instack[v] = 1;Q.push(v);}}}instack[u] = 0;} }int visit[200007];void dfs(int x){for(int e = heads[x];e != -1;e = Es[e].nxt){int v = Es[e].v;if(d[v] == d[x] + Es[e].cost){if(!visit[e]){visit[e] = 1;addedge(x-1,v-1,1);dfs(v);}} }}int main(){int T;scanf("%d",&T);while(T--){init();int n,m;scanf("%d%d",&n,&m);for(int i = 0;i < m;i++){int a,b,c;scanf("%d%d%d",&a,&b,&c);if(a == b) continue;add_edge(a,b,c);} int beg,tar;scanf("%d%d",&beg,&tar);prepare(n,beg-1,tar-1);spfa(beg);memset(visit,0,sizeof(visit));dfs(beg);int ans = Dinic_flow();printf("%d\n",ans);}return 0;}