HDU 3416 Marriage Match IV 【最短路】(记录路径)+【最大流】

<题目链接>

题目大意：

给你一张图，问你其中没有边重合的最短路径有多少条。

解题分析：

建图的时候记得存一下链式后向边，方便寻找最短路径，然后用Dijkstra或者SPFA跑一遍最短路，从终点开始DFS，找出最短路径上所有的边，然后将其加入网络，所有边的容量置为1，以起点为源点，终点为汇点，跑一遍最大流，求出的结果即为最短路的数量。

Dijkstra+Dinic版：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <queue>
 #include <algorithm>
 using namespace std;

 ;
 ;
 const int INF = 0x3f3f3f3f;

 int n, m, st, ed, cnt, cnt1;
 int head[N], head1[N], dep[N], tail[N];
 bool vis[N];

 struct Edge{
     int u, v, w, next, next1;
 }edge[M<<], edge1[M<<];

 struct Node{
     int index,dist;
     bool operator < (const Node &tmp )const{
         return dist>tmp.dist;
     }
 }node[M<<];

 void init(){
     cnt = ,cnt1 = ;
     memset(head, -, sizeof head);
     memset(head1, -, sizeof head1);
     memset(tail, -, sizeof tail);
 }
 void addedge(int u, int v, int w){     //建图，跑最短路
     edge[cnt].u = u; edge[cnt].v = v;
     edge[cnt].w = w; edge[cnt].next = head[u];
     head[u] = cnt;
     edge[cnt].next1 = tail[v];     //tail[]数组相当于是反向的head[]数组，链式后向边，用来寻找最短路径上的边
     tail[v] = cnt++;
 }
 void addedge1(int u, int v, int w){    //建图，跑最大流
     edge1[cnt1].u = u; edge1[cnt1].v = v;
     edge1[cnt1].w = w; edge1[cnt1].next = head1[u];
     head1[u] = cnt1++;           //正向弧

     edge1[cnt1].v = u; edge1[cnt1].u = v;
     edge1[cnt1].w = ; edge1[cnt1].next = head1[v];
     head1[v] = cnt1++;           //反向弧
 }

 int Dij(){
     priority_queue<Node>q;
     ;i<=n;i++)
         vis[i] = false,node[i].index=i,node[i].dist=INF;
     node[st].dist=;
     q.push(node[st]);
     while(!q.empty()){
         int u=q.top().index;q.pop();
         if(vis[u])continue;
         vis[u]=true;
         for(int i=head[u];~i;i=edge[i].next){
             int v = edge[i].v;
             if(node[v].dist>node[u].dist+edge[i].w){
                 node[v].dist = node[u].dist+edge[i].w;
                 q.push(node[v]);
             }
         }
     }
     return node[ed].dist!= INF;
 }

 void dfs(int v){    //寻找最短路中的所有边，并将其加入网络
     ; i = edge[i].next1){
         int u = edge[i].u;   //u为该后向边的起始点
         if(node[u].dist+edge[i].w == node[v].dist){   //判断该边是否为最短路中的边
             addedge1(u, v, );    //如果是的话，就加入网络中，跑最大流
             if(!vis[u]){
                 vis[u] = ;
                 dfs(u);
             }
         }
     }
 }

 /*--    Dinic    --*/
 bool bfs(){
     memset(vis, , sizeof vis);
     memset(dep, -, sizeof dep);
     queue<int> q;
     q.push(st);
     vis[st] = ;
     dep[st] = ;
     while(!q.empty()){
         int cur = q.front();q.pop();
         ; i = edge1[i].next){
             int v = edge1[i].v;
             ){
                 dep[v] = dep[cur]+;
                 vis[v] = ;
                 q.push(v);
             }
         }
     }
     ;   //如果dep[ed]!=-1，说明仍然存在增广路
 }

 int dfs1(int cur, int flow){
     if(cur == ed) return flow;
     ;
      && flow > res; i = edge1[i].next){
         int v = edge1[i].v;
          && dep[v] == dep[cur]+){
             int x = min(edge1[i].w, flow-res);
             int f = dfs1(v, x);
             edge1[i].w-=f;
             edge1[i^].w+=f;
             res += f;
         }
     }
     ;
     return res;
 }

 int dinic(){
     ,res;
     while(bfs()){
         while(res = dfs1(st, INF)){
             sumflow += res;
         }
     }
     return sumflow;
 }
 /*--    Dinic    --*/

 int main(){
     int T; scanf("%d", &T);
     while(T--){
         init();
         scanf("%d%d", &n, &m);
         ; i < m; i++){
             int u, v, w;
             scanf("%d%d%d", &u, &v, &w);
             addedge(u, v, w);
         }
         scanf("%d%d", &st, &ed);
         ");    //跑最短路,如果st->ed不可达，则直接输出0
         else{
             memset(vis,false,sizeof(vis));    //注意，dijkstra要加上这一句，spfa则不用，因为spfa结束后，所有点的vis全部置为false
             dfs(ed);   //找到最短路中的所有边，并将其加入网络
             printf("%d\n",dinic());    //根据最短路所有的边求最大流
         }
     }
     ;
 }

SPFA+Dinic版：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <queue>
 #include <algorithm>
 using namespace std;

 ;
 ;
 const int INF = 0x3f3f3f3f;

 int n, m, st, ed, cnt, cnt1;
 int head[N], head1[N], dis[N], dep[N], tail[N];
 bool vis[N];

 struct Edge{
     int u, v, w, next, next1;
 }edge[M<<], edge1[M<<];

 void init(){
     cnt = ,cnt1 = ;
     memset(head, -, sizeof head);
     memset(head1, -, sizeof head1);
     memset(tail, -, sizeof tail);
 }
 void addEdge1(int u, int v, int w){     //建图，跑最短路
     edge[cnt].u = u; edge[cnt].v = v;
     edge[cnt].w = w; edge[cnt].next = head[u];
     head[u] = cnt;
     edge[cnt].next1 = tail[v];     //tail[]数组相当于是反向的head[]数组，链式后向边，用来寻找最短路径上的边
     tail[v] = cnt++;
 }
 void addEdge2(int u, int v, int w){    //建图，跑最大流
     edge1[cnt1].u = u; edge1[cnt1].v = v;
     edge1[cnt1].w = w; edge1[cnt1].next = head1[u];
     head1[u] = cnt1++;           //正向弧

     edge1[cnt1].v = u; edge1[cnt1].u = v;
     edge1[cnt1].w = ; edge1[cnt1].next = head1[v];
     head1[v] = cnt1++;           //反向弧
 }

 int spfa(){
     queue<int> q;
     ; i <= n; i++)
         vis[i] = ,dis[i] = INF;
     vis[st] = ; dis[st] = ;
     q.push(st);
     while(!q.empty()){
         int cur = q.front();
         q.pop(); vis[cur] = ;
         ; i = edge[i].next)
         {
             int v = edge[i].v;
             if(dis[v] > dis[cur]+edge[i].w)
             {
                 dis[v] = dis[cur]+edge[i].w;
                 if(!vis[v])
                 {
                     vis[v] = ;
                     q.push(v);
                 }
             }
         }
     }
     return dis[ed] != INF;
 }

 void dfs(int v){    //寻找最短路中的所有边，并将其加入网络
     ; i = edge[i].next1){
         int u = edge[i].u;   //u为该后向边的起始点
         if(dis[u]+edge[i].w == dis[v]){   //判断该边是否为最短路中的边
             addEdge2(u, v, );    //如果是的话，就加入网络中，跑最大流
             if(!vis[u]){
                 vis[u] = ;
                 dfs(u);
             }
         }
     }
 }

 /*--    Dinic    --*/
 bool bfs(){
     memset(vis, , sizeof vis);
     memset(dep, -, sizeof dep);
     queue<int> q;
     q.push(st);
     vis[st] = ;
     dep[st] = ;
     while(!q.empty()){
         int cur = q.front();q.pop();
         ; i = edge1[i].next){
             int v = edge1[i].v;
             ){
                 dep[v] = dep[cur]+;
                 vis[v] = ;
                 q.push(v);
             }
         }
     }
     ;   //如果dep[ed]!=-1，说明仍然存在增广路
 }

 int dfs1(int cur, int flow){
     if(cur == ed) return flow;
     ;
      && flow > res; i = edge1[i].next){
         int v = edge1[i].v;
          && dep[v] == dep[cur]+){
             int x = min(edge1[i].w, flow-res);
             int f = dfs1(v, x);
             edge1[i].w-=f;
             edge1[i^].w+=f;
             res += f;
         }
     }
     ;
     return res;
 }

 int dinic(){
     ,res;
     while(bfs()){
         while(res = dfs1(st, INF)){
             sumflow += res;
         }
     }
     return sumflow;
 }
 /*--    Dinic    --*/

 int main(){
     int T; scanf("%d", &T);
     while(T--){
         init();
         scanf("%d%d", &n, &m);
         ; i < m; i++){
             int u, v, w;
             scanf("%d%d%d", &u, &v, &w);
             addEdge1(u, v, w);
         }
         scanf("%d%d", &st, &ed);
         ");    //跑最短路,如果st->ed不可达，则直接输出0
         else{
             dfs(ed);   //找到最短路中的所有边，并将其加入网络
             printf("%d\n",dinic());    //根据最短路所有的边求最大流
         }
     }
     ;
 }

2018-11-23