isap 最大流 模版

hdu  4289  control   

 http://acm.hdu.edu.cn/showproblem.php?pid=4289

 

我自己的代码：

  1 #include<cstdio>
  2 #include<cstring>
  3 #include<cmath>
  4 #include<iostream>
  5 #include<algorithm>
  6 #include< set>
  7 #include<map>
  8 #include<queue>
  9 #include<vector>
 10 #include< string>
 11  #define INF 0x7fffffff
 12  #define maxn 500
 13  #define CL(a,b) memset(a,b,sizeof(a))
 14 
 15  using  namespace std;
 16  struct node
 17 {
 18      int to;
 19      int cap;
 20      int  next;
 21 }p[ 200000] ;
 22  int dis[maxn],gap[maxn] ,cnt,next[maxn],s,e; //  dis[i]为 到达 原点的层数
 23  int  n , m,NN ; // NN 为  加完点 之后的 总结点数
 24  void add( int  from, int to, int cap) // 加 的 是 有向边
 25  {
 26     p[cnt].to = to;
 27     p[cnt].cap = cap ;
 28     p[cnt].next = next[ from];
 29     next[ from] = cnt++;
 30 
 31     p[cnt].to =  from;
 32     p[cnt].cap =  0;
 33     p[cnt].next = next[to];
 34     next[to] = cnt++ ;
 35 }
 36  int dfs( int pos, int cost)
 37 {
 38 
 39      if(pos == e)
 40       return cost ;
 41 
 42      int i,j ,mdis = NN ,f = cost ;
 43 
 44      for(i =  next[pos];i != -  1; i = p[i].next)
 45     {
 46          int to = p[i].to ;
 47          int cap = p[i].cap ;
 48          if(cap >  0 )
 49         {
 50              if(dis[to] +  1 == dis[pos])
 51             {
 52 
 53 
 54                int d = min(f,cap) ; //  注意 这 为 剩余 流量 和 cap 的 最小值
 55 
 56               d = dfs(to,d) ;
 57               p[i].cap -=d;
 58               p[i^ 1].cap +=d;
 59               f -= d;
 60 
 61                if(dis[s] >= NN)   return cost - f; //  如果没有 了 增广路经 结束算法
 62                 if(f ==  0)  break ;
 63             }
 64              if( dis[to] < mdis ) mdis = dis[to] ; //  记录可扩展的最小的狐
 65 
 66         }
 67 
 68     }
 69      if(f == cost) //   没有 可以 扩展的点
 70      {
 71         --gap[dis[pos]];
 72          if(gap[dis[pos]] ==  0)dis[s] = NN; //  注意这 ，若 距离 为 dis[pos] 这一层都没有 扩展点了(断层) dis[s] = n
 73 
 74         dis[pos] = mdis +  1;// 维护距离标号的方法是这样的：当找增广路过程中发现某点出发没有允许弧时，将这个点的距离标号设为由它出发的所有弧的终点的距离标号的最                                     小值加一
 75 
 76         ++gap[dis[pos]] ;
 77     }
 78      return cost  - f ;
 79 }
 80  int isap(  int b, int t)
 81 {
 82 
 83      int ret =   0;
 84     s = b;
 85     e = t;
 86     CL(gap, 0);
 87     CL(dis, 0) ;
 88     gap[s] = NN ; // NN 为  加完点 之后的 总结点数
 89       while(dis[s] < NN)
 90     {
 91         ret+=dfs(s,INF) ;
 92     }
 93      return ret ;
 94 
 95 }
 96  int main()
 97 {
 98      int  i,x,y,a,b,t;
 99      // freopen("data.txt","r",stdin) ;
100       while(scanf( " %d%d%d%d ",&n,&m,&b,&t)!=EOF)
101     {
102         CL(next,- 1);
103         cnt =  0 ;
104         NN =  2*n  ; // NN 为  加完点 之后的 总结点数
105           for(i =  1;i <=n;i++)
106         {
107             scanf( " %d ",&a);
108             add(i,i+n,a) ;
109         }
110          for(i =  0; i<m;i++)
111         {
112             scanf( " %d%d ",&x,&y);
113             add(x+n,y,INF);
114             add(y + n,x,INF);
115         }
116 
117          int ans = isap(b,t + n) ;
118         printf( " %d\n ",ans) ;
119     }
120 }

 

讲解：

http://hi.baidu.com/jhubtjkpmbfpqzr/item/9223a400c14418dbdce5b027 

另一 讲解：

[转载]网络流ISAP算法的简单介绍

原文 from Lost 庄神

原来我的模板是这么来的。至今思网络，不知怎么流。惭愧啊……

ISAP全称Improved Shortest Augmenting Path，由Ahuja和Orlin在1987年提出，而下文讲的是加上gap优化的ISAP。

顺便，其实这篇写得比较入门和清楚。

====

　　这几天由于种种原因经常接触到网络流的题目，这一类型的题给人的感觉，就是要非常使劲的YY才能出来点比较正常的模型。尤其是看了Amber最 小割应用的文章，里面的题目思路真是充满了绵绵不绝的YD思想。然而比赛中，当你YD到了这一层后，您不得不花比较多的时间去纠结于大量细节的实现，而冗 长的代码难免会使敲错版后的调试显得异常悲伤，因此一些巧妙简短高效的网络流算法在此时便显得犹为重要了。本文力求以最简短的描述，对比较流行的网络流算 法作一定的总结，并借之向读者强烈推荐一种效率与编程复杂度相适应的算法。

　　众所周知，在网络流的世界里，存在2类截然不同的求解思想，就是比较著名的预流推进与增广路，两者都需要反向边的小技巧。

　　其中预流推进的算法思想是以边为单元进行推流操作。具体流程如下:置初始点邻接边满流并用一次反向bfs对每个结点计算反向距离标号，定义除汇 点外存量大于出量的结点为活动结点，每次对活动结点按允许边（u->v:d[u]=d[v]+1）进行推流操作，直到无法推流或者该点存量为0，若 u点此时仍为活动结点，则进行重标号，使之等于原图中进行推操作后的邻接结点的最小标号+1，并将u点入队。当队列为空时，算法结束，只有s点和t点存量 非0，网络中各顶点无存量，无法找到增广路继续增广，则t点存量为最大流。

　　而增广路的思想在于每次从源点搜索出一条前往汇点的增广路，并改变路上的边权，直到无法再进行增广，此时汇点的增广量即为最大流。两者最后的理 论基础依然是增广路定理，而在理论复杂度上预流推进要显得比较优秀。其中的HLPP高标预流推进的理论复杂度已经达到了另人发指的 O（sqrt(m)*n*n），但是其编程复杂度也是同样的令人发指- -

　　于是我们能否在编程复杂度和算法复杂度上找到一个平衡呢，答案是肯定的。我们使用增广路的思想，而且必须进行优化。因为原始的增广路算法（例如 EK）是非常悲剧的。于是有人注意到了预流推进中的标号法，在增广路算法中引入允许弧概念，每次反搜残留网络得到结点标号，在正向增广中利用递归进行连续 增广，于是产生了基于分层图的Dinic算法。一些人更不满足于常规Dinic所带来的提升，进而加入了多路分流增广的概念，即对同一顶点的流量，分多路 同时推进，再加上比较复杂的手工递归，使得Dinic已经满足大部分题目的需要。

　　然而这样做就是增广路算法优化的极限么？答案永远是不。人们在Dinic中只类比了预流推进的标号技术，而重标号操作却没有发挥得淋漓尽致。于 是人们在Dinic的基础上重新引入了重标号的概念，使得算法无须在每次增广后再进行BFS每个顶点进行距离标号，这种主动标号技术使得修正后算法的速度 有了不少提高。但这点提高是不足称道的，人们又发现当某个标号的值没有对应的顶点后，即增广路被截断了，于是算法便可以提前结束，这种启发式的优化称为 Gap优化。最后人们结合了连续增广，分层图，多路增广，Gap优化，主动标号等穷凶极恶的优化，更甚者在此之上狂搞个手动递归，于是产生了增广路算法的 高效算法–ISAP算法。

　　虽然ISAP算法的理论复杂度仍然不可超越高标预流推进，但其编程复杂度已经简化到发指，如此优化，加上不逊于Dinic的速率（在效率上手工Dinic有时甚至不如递归ISAP），我们没有不选择它的理由。

　　因此本文强烈推荐ISAP作为网络流首选算法。

　　其实现方法见下文，除去例行的添边操作，不超过50行的代码，何乐而不为之，以下实现仍有优化的余地（在计算初始标号时，为减小代码量直接忽略之，其复杂度不变，但实现后效率有5%左右的下降，如果乐意修正的话可以进行改良，当然不修正不影响算法正确性）。

View Code

  1 typedef   struct { int v,next,val;} edge;
  2  const  int MAXN= 20010;
  3  const  int MAXM= 500010;
  4  
  5 edge e[MAXM];
  6  int p[MAXN],eid;
  7  
  8 inline  void init(){memset(p,- 1, sizeof(p));eid= 0;}
  9  
 10  // 有向
 11  inline  void insert1( int  from, int to, int val)
 12 {
 13     e[eid].v=to;
 14     e[eid].val=val;
 15     e[eid].next=p[ from];
 16     p[ from]=eid++;
 17  
 18     swap( from,to);
 19  
 20     e[eid].v=to;
 21     e[eid].val= 0;
 22     e[eid].next=p[ from];
 23     p[ from]=eid++;
 24 }
 25  
 26  // 无向
 27  inline  void insert2( int  from, int to, int val)
 28 {
 29     e[eid].v=to;
 30     e[eid].val=val;
 31     e[eid].next=p[ from];
 32     p[ from]=eid++;
 33  
 34     swap( from,to);
 35  
 36     e[eid].v=to;
 37     e[eid].val=val;
 38     e[eid].next=p[ from];
 39     p[ from]=eid++;
 40 }
 41  
 42  int n,m; // n为点数 m为边数
 43  int h[MAXN];
 44  int gap[MAXN];
 45  
 46  int source,sink;
 47 inline  int dfs( int pos, int cost)
 48 {
 49      if (pos==sink)
 50     {
 51          return cost;
 52     }
 53  
 54      int j,minh=n- 1,lv=cost,d;
 55  
 56      for (j=p[pos];j!=- 1;j=e[j].next)
 57     {
 58          int v=e[j].v,val=e[j].val;
 59          if(val> 0)
 60         {
 61              if (h[v]+ 1==h[pos])
 62             {
 63                  if (lv<e[j].val) d=lv;
 64                  else d=e[j].val;
 65  
 66                 d=dfs(v,d);
 67                 e[j].val-=d;
 68                 e[j^ 1].val+=d;
 69                 lv-=d;
 70                  if (h[source]>=n)  return cost-lv;
 71                  if (lv== 0)  break;
 72             }
 73  
 74              if (h[v]<minh)    minh=h[v];
 75         }
 76     }
 77  
 78      if (lv==cost)
 79     {
 80         --gap[h[pos]];
 81          if (gap[h[pos]]== 0) h[source]=n;
 82         h[pos]=minh+ 1;
 83         ++gap[h[pos]];
 84     }
 85  
 86      return cost-lv;
 87  
 88 }
 89  
 90  int sap( int st, int ed)
 91 {
 92  
 93     source=st;
 94     sink=ed;
 95      int ret= 0;
 96     memset(gap, 0, sizeof(gap));
 97     memset(h, 0, sizeof(h));
 98  
 99     gap[st]=n;
100  
101      while (h[st]<n)
102     {
103         ret+=dfs(st,INT_MAX);
104     }
105  
106      return ret;
107 }

 

我本来是只会EK的，就是那个最经典，也是最白痴的算法……（不过有些时候正经很好用呢~）

昨天和王正宇大牛在机房研究了一下神奇的SAP算法，今天又拿他做了一些网络流的题目，发现确实优化效果极其明显！

 

我在学的时候看的是DD_engi神牛的讲解。我这里简单总结一下：

首先我么先回顾一下EK（这个不会的可以看namiheike写的EK的详解，地址：http://www.oibh.org/bbs /thread-29333-1-1.html）。EK的思想就是每一次都用一个BFS来找到一条增广路，所以说我们就会发现他的复杂度 是：O(V*E^2)。所以说我们找到的不一定就是最优的。

 

本人的总结能力有限，以下给出dd_engi神牛的讲解：

 

求最大流有一种经典的算法，就是每次找增广路时用BFS找，保证找到的增广路是弧数最少的，也就是所谓的Edmonds-Karp算法。可以证明的 是在使用最短路增广时增广过程不超过V*E次，每次BFS的时间都是O(E)，所以Edmonds-Karp的时间复杂度就是O(V*E^2)。

 

如果能让每次寻找增广路时的时间复杂度降下来，那么就能提高算法效率了，使用距离标号的最短增广路算法就是这样的。所谓距离标号，就是某个点到汇点 的最少的弧的数量（另外一种距离标号是从源点到该点的最少的弧的数量，本质上没什么区别）。设点i的标号为D[i]，那么如果将满足 D[i]=D[j]+1的弧(i,j)叫做允许弧，且增广时只走允许弧，那么就可以达到“怎么走都是最短路”的效果。每个点的初始标号可以在一开始用一次 从汇点沿所有反向边的BFS求出，实践中可以初始设全部点的距离标号为0，问题就是如何在增广过程中维护这个距离标号。

 

维护距离标号的方法是这样的：当找增广路过程中发现某点出发没有允许弧时，将这个点的距离标号设为由它出发的所有弧的终点的距离标号的最小值加一。 这种维护距离标号的方法的正确性我就不证了。由于距离标号的存在，由于“怎么走都是最短路”，所以就可以采用DFS找增广路，用一个栈保存当前路径的弧即 可。当某个点的距离标号被改变时，栈中指向它的那条弧肯定已经不是允许弧了，所以就让它出栈，并继续用栈顶的弧的端点增广。为了使每次找增广路的时间变成 均摊O(V)，还有一个重要的优化是对于每个点保存“当前弧”：初始时当前弧是邻接表的第一条弧；在邻接表中查找时从当前弧开始查找，找到了一条允许弧， 就把这条弧设为当前弧；改变距离标号时，把当前弧重新设为邻接表的第一条弧，还有一种在常数上有所优化的写法是改变距离标号时把当前弧设为那条提供了最小 标号的弧。当前弧的写法之所以正确就在于任何时候我们都能保证在邻接表中当前弧的前面肯定不存在允许弧。

 

还有一个常数优化是在每次找到路径并增广完毕之后不要将路径中所有的顶点退栈，而是只将瓶颈边以及之后的边退栈，这是借鉴了Dinic算法的思想。 注意任何时候待增广的“当前点”都应该是栈顶的点的终点。这的确只是一个常数优化，由于当前边结构的存在，我们肯定可以在O(n)的时间内复原路径中瓶颈 边之前的所有边。

 

优化：

1.邻接表优化：

如果顶点多的话，往往N^2存不下，这时候就要存边：

存每条边的出发点，终止点和价值，然后排序一下，再记录每个出发点的位置。以后要调用从出发点出发的边时候，只需要从记录的位置开始找即可（其实可以用链表）。优点是时间加快空间节省，缺点是编程复杂度将变大，所以在题目允许的情况下，建议使用邻接矩阵。

 

2.GAP优化：

如果一次重标号时，出现距离断层，则可以证明ST无可行流，此时则可以直接退出算法。

 

3.当前弧优化：

为了使每次找增广路的时间变成均摊O(V)，还有一个重要的优化是对于每个点保存“当前弧”：初始时当前弧是邻接表的第一条弧；在邻接表中查找时从当前弧开始查找，找到了一条允许弧，就把这条弧设为当前弧；改变距离标号时，把当前弧重新设为邻接表的第一条弧。

 

学过之后又看了算法速度的比较，发现如果写好的话SAP的速度不会输给HLPP。

====

View Code

 1 #include <cstdio>
 2 #include <cstring>
 3  using  namespace std;
 4  const  int V= 220,E= 220;
 5 
 6  int n,m,h[V],vh[V];
 7 
 8  struct etype
 9 {
10      int t,u;
11     etype *next,*pair;
12     etype(){}
13     etype( int t_, int u_,etype* next_):t(t_),u(u_),next(next_){}
14      void*  operator  new(unsigned, void* p){ return p;}
15 } *e[V],*eb[V],Te[E+E],*Pe=Te;
16 
17  int aug( int no, int m)
18 {
19      if(no==n) return m;
20      int l=m;
21      for(etype *&i=e[no];i;i=i->next)
22          if(i->u && h[i->t]+ 1==h[no])
23         {
24              int d=aug(i->t,l<i->u?l:i->u);
25             i->u-=d,i->pair->u+=d,l-=d;
26              if(h[ 1]==n || !l) return m-l;
27         }
28      int minh=n;
29      for(etype *i=e[no]=eb[no];i;i=i->next) if(i->u)
30          if(h[i->t]+ 1<minh)minh=h[i->t]+ 1;
31      if(!--vh[h[no]])h[ 1]=n; else ++vh[h[no]=minh];
32      return m-l;
33 }
34     
35  int main()
36 {
37     freopen( " ditch.in ", " r ",stdin);
38     freopen( " ditch.out ", " w ",stdout);
39     scanf( " %d %d ",&m,&n);
40     memset(e, 0, sizeof(e));
41      while(m--)
42     {
43          int s,t,u;
44         scanf( " %d %d %d ",&s,&t,&u);
45         e[s]= new(Pe++)etype(t,u,e[s]);
46         e[t]= new(Pe++)etype(s, 0,e[t]);
47         e[s]->pair=e[t];
48         e[t]->pair=e[s];
49     }
50     memmove(eb,e, sizeof(e));
51     memset(h, 0, sizeof(h));
52     memset(vh, 0, sizeof(vh));
53     vh[ 0]=n;
54      int ans= 0;
55      while(h[ 1]<n)ans+=aug( 1,~ 0U>> 1);
56     printf( " %d\n ",ans);
57      return  0;
58 }