HDU 3416 Marriage Match IV(中等，好题) [最大流]最短路+最大流

题意：告诉你一个有向图，现在，从A到B问最短的路有几条（一条路走过就不能在走了，某个顶点可以走多次）
思路：首先我们需要找出最短路（我用的是spfa），然后用这些在最短路上的边形成一个最短路边的网络。最后把这些边的权值设为1，跑一遍最大流即可。跑两边最短路是用于判断一条边是不是在最短路上，比如边i–>j，d[i]+d2[j]+weight(i,j)==最短路距离。那么i–>j就在最短路上，d[i] 表示正向的最短路径，d2[i]表示反向的

#include<cstdio>
#include<algorithm>
#include<cmath>
#include<queue>
#include<cstring>
using namespace std;
#define pb push_back
#define cl(a,b) memset(a,b,sizeof(a))
const int maxn=1005;
const int inf=1<<28;

template<int nv,int ne>
struct isap{
    int n,size;
    int head[nv];
    int dis[nv],gap[nv],cur[nv],pre[nv];
    int maxflow;

    struct edge{
        int v,w,next;
        edge(){}
        edge(int _v,int _w,int _next):v(_v),w(_w),next(_next){}
    }E[ne];

    void init(int n){
        this->n=n,size=0;
        cl(head,-1);
    }
    void insert(int u,int v,int w){
        E[size]=edge(v,w,head[u]);
        head[u]=size++;
        E[size]=edge(u,0,head[v]);
        head[v]=size++;
    }
    int maxFlow(int src,int des){
        maxflow=0;
        for(int i=0;i<=n;i++){
            dis[i]=gap[i]=0;
            cur[i]=head[i];
        }
        int u=pre[src]=src;
        int aug=0;///or aug=-1
        while(dis[src]<n){
           loop:for(int &i=cur[u];i!=-1;i=E[i].next){
                int v=E[i].v;
                if(E[i].w&&dis[u]==dis[v]+1){
                    aug=min(aug,E[i].w);
                    pre[v]=u;
                    u=v;
                    if(v==des){
                        maxflow+=aug;
                        for(u=pre[u];v!=src;v=u,u=pre[u]){
                            E[cur[u]].w-=aug;
                            E[cur[u]^1].w+=aug;
                        }
                        aug=inf;
                    }
                    goto loop;
                }
            }
            int mdis=n;
            for(int i=head[u];i!=-1;i=E[i].next){
                int v=E[i].v;
                if(E[i].w&&mdis>dis[v]){
                    cur[u]=i;
                    mdis=dis[v];
                }
            }
            if(--gap[dis[u]]==0)break;
            gap[dis[u]=mdis+1]++;
            u=pre[u];
        }
        return maxflow;
    }
};
isap<1005,200005> G;

struct Edge{
    int v,w;
    Edge(){}
    Edge(int _a,int _b):v(_a),w(_b){}
};
vector<Edge> GG[maxn],GG2[maxn];
bool inq[maxn];
int d[maxn];
int spfa(int src,int des){
    cl(inq,false);
    fill(d,d+maxn,inf);
    queue<int> q;
    q.push(src);
    inq[src]=true;
    d[src]=0;
    while(!q.empty()){
        int u=q.front();q.pop();
        for(int i=0;i<GG[u].size();i++){
            int v=GG[u][i].v;
            if(d[v]>d[u]+GG[u][i].w){
                d[v]=d[u]+GG[u][i].w;
                if(!inq[v]){
                    inq[v]=true;
                    q.push(v);
                }
            }
        }
        inq[u]=false;
    }
    return d[des];
}
int d2[maxn];
void spfa2(int src,int des){
    cl(inq,false);
    fill(d2,d2+maxn,inf);
    queue<int> q;
    q.push(src);
    inq[src]=true;
    d2[src]=0;
    while(!q.empty()){
        int u=q.front();q.pop();
        for(int i=0;i<GG2[u].size();i++){
            int v=GG2[u][i].v;
            if(d2[v]>d2[u]+GG2[u][i].w){
                d2[v]=d2[u]+GG2[u][i].w;
                if(!inq[v]){
                    inq[v]=true;
                    q.push(v);
                }
            }
        }
        inq[u]=false;
    }
}
int main(){
    int T;
    scanf("%d",&T);
    int n,m;
    while(T--){
        scanf("%d%d",&n,&m);
        for(int i=1;i<maxn;i++){
            GG[i].clear();
            GG2[i].clear();
        }
        for(int i=0;i<m;i++){
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            if(u==v)continue;
            GG[u].pb(Edge(v,w));//正向图
            GG2[v].pb(Edge(u,w));//反向图
        }
        int A,B;
        scanf("%d%d",&A,&B);
        int x=spfa(A,B);
        spfa2(B,A);
        G.init(n);
        for(int i=1;i<=n;i++){
            for(int j=0;j<GG[i].size();j++){
                int v=GG[i][j].v;
                if(d[i]+d2[v]+GG[i][j].w==x){
                    G.insert(i,v,1);//最短路集边，构成新的网络
                }
            }
        }
        printf("%d\n",G.maxFlow(A,B));
    }
    return 0;
}