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=;
 const int maxm=;
 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,-,sizeof(head1));
     tot=;
 }

 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,-,sizeof(pre));
     dis[s]=;
     while(!q.empty())
         q.pop();
     node a(,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!=-;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 = ;
 const int MAXM = ;
 struct Temp
 {
     int u,v;
 }temp[MAXM];
 int cnt;
 void dfs(int u)
 {
     for(int i=head1[u];i!=-;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 = ;
     memset(head, -, sizeof(head));
 }
 void addedge(int u, int v, int w, int rw=)
 {
     edge[tol].to = v; edge[tol].cap = w; edge[tol].flow = ;
     edge[tol].next = head[u]; head[u] = tol++;
     edge[tol].to = u; edge[tol].cap = rw; edge[tol].flow = ;
     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 = , tail = ;
     memset(dep, -, sizeof(dep[])*(n+));
     dep[s] = ;
     Q[tail++] = s;
     while(front < tail)
     {
         int u = Q[front++];
         for(int i = head[u]; i != -; i = edge[i].next)
         {
             int v = edge[i].to;
             if(edge[i].cap > edge[i].flow && dep[v] == -)                         {
                 dep[v] = dep[u] + ;
                 if(v == t) return true;
                 Q[tail++] = v;
             }
         }
     }
     return false;
 }
 int dinic(int s, int t, int n) {
     int maxflow = ;
     while(bfs(s, t, n)) {
         for(int i = ; i < n; i++) cur[i] = head[i];
         int u = s, tail = ;
         while(cur[s] != -)
         {
             if(u == t)
             {
                 int tp = INF;
                 for(int i = tail-; i >= ; i--)
                     tp = min(tp, edge[sta[i]].cap-edge[sta[i]].flow);
                 maxflow+=tp;
                 for(int i = tail-; i >= ; i--) {
                     edge[sta[i]].flow+=tp;
                     edge[sta[i]^].flow-=tp;
                     if(edge[sta[i]].cap-edge[sta[i]].flow==)
                         tail = i;
                 }
                 u = edge[sta[tail]^].to;
             }
             else
                 if(cur[u] != - && edge[cur[u]].cap > edge[cur[u]].flow && dep[u] +  == dep[edge[cur[u]].to])
                 {
                     sta[tail++] = cur[u];
                     u = edge[cur[u]].to;
                 }
                 else
                 {
                     while(u != s && cur[u] == -)
                         u = edge[sta[--tail]^].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=;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=;
         dfs(a);
         init();
         for(int i=;i<cnt;++i)
             addedge(temp[i].u-,temp[i].v-,);
         int ans=dinic(a-,b-,n);
         cout<<ans<<endl;
     }
     return ;
 }