hdu 3416 Marriage Match IV （最大流判断最短路数量）

题意：

给个图，还有s点和t点，问从s到t的最短路有几条

分析：

学到了新操作，跑完最短路算法之后可以用dist数组可以判断某条边是否在最短路路径上

我看到一个方法是跑两次最短路，一次s到t，一次t到s
左端点到s的最短路长度加上右端点到t的最短路长度加上当前边权
如果这个值等于s到t的最短路长度，那么这条边就在最短路的路径上

还有一种是只跑一次最短路
右端点（离t点近的）到t的最短路长度加上当前边权
如果值等于左端点（离t点远的）到t的最短路长度，那么这条边就在最短路的路径上

然后把在最短路径上的边加入最大流的图 容量设置为1
跑一遍s到t的最大流，最大流量就是最短路的条数

code：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<algorithm>
#include<map>
#include<set>
typedef long long ll;
const int inf=0x3f3f3f3f;
const int inn=0x80808080;
using namespace std;
const int N=1e3+5;
const int M=1e5+5;
struct Node{//求最短路的时候用的
    int to,nt,w;
}e[M*2];
struct Node2{//求最大流时候用的
    int to,nt,w;
}ee[M*2];//名字和上面的不一样哦
int head[N];//最短路的
int head2[N];//最大流的
int d1[N];//spfa的路径长度
int mark[N];//spfa的标记
int d[N];//bfs的层次
int cnt;
int s,t;//源点、汇点
int maxflow;//最大流
void init(){//初始化
    cnt=-1;
    memset(head,-1,sizeof head);
    memset(head2,-1,sizeof head2);
}
void add(int x,int y,int z){//添加最短路的边
    cnt++;
    e[cnt].nt=head[x];
    head[x]=cnt;
    e[cnt].to=y;
    e[cnt].w=z;
}
void add2(int x,int y,int z){//添加最大流的边
    cnt++;
    ee[cnt].nt=head2[x];
    head2[x]=cnt;
    ee[cnt].to=y;
    ee[cnt].w=z;
    cnt++;
    ee[cnt].nt=head2[y];
    head2[y]=cnt;
    ee[cnt].to=x;
    ee[cnt].w=0;
}
void spfa(int ss){//求最短路
    queue<int>q;
    memset(mark,0,sizeof mark);
    memset(d1,inf,sizeof d1);
    d1[ss]=0;
    q.push(ss);
    mark[ss]=1;
    while(!q.empty()){
        int x=q.front();
        q.pop();
        mark[x]=0;
        for(int i=head[x];i!=-1;i=e[i].nt){
            int v=e[i].to;
            if(d1[v]>d1[x]+e[i].w){
                d1[v]=d1[x]+e[i].w;
                if(!mark[v]){
                    mark[v]=1;
                    q.push(v);
                }
            }
        }
    }
}
bool bfs(){
    memset(d,0,sizeof d);
    queue<int>q;
    q.push(s);
    d[s]=1;
    while(!q.empty()){
        int x=q.front();
        q.pop();
        for(int i=head2[x];i!=-1;i=ee[i].nt){
            int v=ee[i].to;
            if(ee[i].w&&!d[v]){
                d[v]=d[x]+1;
                q.push(v);
                if(v==t)return 1;
            }
        }
    }
    return 0;
}
int dfs(int x,int flow){
    if(x==t)return flow;
    int res=flow;
    for(int i=head2[x];i!=-1;i=ee[i].nt){
        int v=ee[i].to;
        if(ee[i].w&&d[v]==d[x]+1){
            int k=dfs(v,min(res,ee[i].w));
            if(!k)d[v]=-1;
            ee[i].w-=k;
            ee[i^1].w+=k;
            res-=k;
            if(res==0)break;
        }
    }
    return flow-res;
}
void dinic(){
    maxflow=0;
    while(bfs()){
        maxflow+=dfs(s,inf);
    }
}
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        init();
        int n,m;
        scanf("%d%d",&n,&m);
        for(int i=1;i<=m;i++){
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            add(a,b,c);//建立求最短路的图
        }
        scanf("%d%d",&s,&t);
        spfa(s);//求最短路
        cnt=-1;
        for(int i=1;i<=n;i++){//遍历所有点
            for(int j=head[i];j!=-1;j=e[j].nt){//遍历所有路径
                if(d1[i]+e[j].w==d1[e[j].to]){//判断当前路径是否为最短路径的边
                    add2(i,e[j].to,1);
                }
            }
        }
        dinic();
        printf("%d\n",maxflow);
    }
    return 0;
}