hdu3416 Marriage Match IV（最短路+网络流）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3416

题意：

给出含n个点、m条有向边的图，每条边只能走一次，给出起点和终点，求起点到终点的最短路径有多少条。

思路：

题目要求是最短路径，当然需要求出最短路，用Dijkstra就可以了，然后我们需要构造网络流的图。将能组成最短路的边加入图中，容量设为1，注意能组成最短路的边是满足dis[u] + edge[i].dist == dis[v] 的边，其中u是边的起点，v是边的终点，dis[]保存的是最短路。最后跑最大流即可。

代码如下：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<queue>

using namespace std;
const int INF=0x3f3f3f3f;
const int maxn=1100;
const int maxm=110000;
struct node
{
    int d,u;
    friend bool operator<(node a,node b)
    {
        return a.d>b.d;
    }
    node(int dist,int point):d(dist),u(point){}
};

struct Edge1
{
    int to,next;
    int dist;
}edge1[maxm];
int head1[maxn],tot;
int pre[maxn],dis[maxn];
bool vis[maxm];

void init1()
{
    memset(head1,-1,sizeof(head1));
    tot=0;
}

void addedge1(int u,int v,int d)
{
    edge1[tot].to=v;
    edge1[tot].dist=d;
    edge1[tot].next=head1[u];
    head1[u]=tot++;
}

void Dijkstra(int s)
{
    priority_queue<node> q;
    memset(dis,0x3f,sizeof(dis));
    memset(pre,-1,sizeof(pre));
    dis[s]=0;
    while(!q.empty())
        q.pop();
    node a(0,s);
    q.push(a);       
    while(!q.empty())
    {
        node x=q.top();
        q.pop();
        if(dis[x.u]<x.d)   
            continue;
        for(int i=head1[x.u];i!=-1;i=edge1[i].next)
        {
            int v=edge1[i].to;
            if(dis[v]>dis[x.u]+edge1[i].dist)
            {
                dis[v]=dis[x.u]+edge1[i].dist;
                pre[v]=x.u;
                q.push(node(dis[v],v));
            }
        }
    }
}
const int MAXN = 2010;
const int MAXM = 1200012;
struct Temp
{
    int u,v;
}temp[MAXM];
int cnt;
void dfs(int u)
{
    for(int i=head1[u];i!=-1;i=edge1[i].next)
    {
        int v=edge1[i].to;
        if(dis[u]+edge1[i].dist==dis[v]&&(!vis[i]))
        {
            temp[cnt].u=u;
            temp[cnt++].v=v;
            vis[i]=true;
            dfs(v);
        }
    }
}

struct Edge2 
{
    int to, next, cap, flow;
}edge[MAXM];
int tol;
int head[MAXN];
void init() 
{
    tol = 2;
    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].flow = 0;
    edge[tol].next = head[u]; head[u] = tol++;
    edge[tol].to = u; edge[tol].cap = rw; edge[tol].flow = 0;
    edge[tol].next = head[v]; head[v] = tol++;
}
int Q[MAXN];
int dep[MAXN], cur[MAXN], sta[MAXN];
bool bfs(int s, int t, int n) 
{
    int front = 0, tail = 0;
    memset(dep, -1, sizeof(dep[0])*(n+1));
    dep[s] = 0;
    Q[tail++] = s;
    while(front < tail)
    {
        int u = Q[front++];
        for(int i = head[u]; i != -1; i = edge[i].next) 
        {
            int v = edge[i].to;
            if(edge[i].cap > edge[i].flow && dep[v] == -1)                         {
                dep[v] = dep[u] + 1;
                if(v == t) return true;
                Q[tail++] = v;
            }
        }
    }
    return false;
}
int dinic(int s, int t, int n) {
    int maxflow = 0;
    while(bfs(s, t, n)) {
        for(int i = 0; i < n; i++) cur[i] = head[i];
        int u = s, tail = 0;
        while(cur[s] != -1)
        {
            if(u == t) 
            {
                int tp = INF;
                for(int i = tail-1; i >= 0; i--)
                    tp = min(tp, edge[sta[i]].cap-edge[sta[i]].flow);
                maxflow+=tp;
                for(int i = tail-1; i >= 0; i--) {
                    edge[sta[i]].flow+=tp;
                    edge[sta[i]^1].flow-=tp;
                    if(edge[sta[i]].cap-edge[sta[i]].flow==0)
                        tail = i;
                }
                u = edge[sta[tail]^1].to;
            }
            else 
                if(cur[u] != -1 && edge[cur[u]].cap > edge[cur[u]].flow && dep[u] + 1 == dep[edge[cur[u]].to]) 
                {
                    sta[tail++] = cur[u];
                    u = edge[cur[u]].to;
                }
                else 
                {
                    while(u != s && cur[u] == -1)
                        u = edge[sta[--tail]^1].to;
                    cur[u] = edge[cur[u]].next;
                }
        }
    }
    return maxflow;
}
int n,m,a,b;

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        init1();
        scanf("%d%d",&n,&m);
        for(int i=1;i<=m;++i)
        {
            int u,v,c;
            scanf("%d%d%d",&u,&v,&c);
            if(u!=v)
                addedge1(u,v,c);
        }
        scanf("%d%d",&a,&b);
        Dijkstra(a);
        memset(vis,false,sizeof(vis));
        cnt=0;
        dfs(a);
        init();
        for(int i=0;i<cnt;++i)
            addedge(temp[i].u-1,temp[i].v-1,1);
        int ans=dinic(a-1,b-1,n);
        cout<<ans<<endl;
    }
    return 0;
}