Ford_Fulkerson算法,EK算法,DInic算法


  1432人阅读  评论(0)  收藏  举报
算法 网络 each path network c

       在算法导论中对求解最大流问题给出了一般性的解决方法,但并没有涉及到具体的实现。在这里我还是重新的对求解最大流的思想进行一般性的描述,然后再给出具体的实现。

      Ford-Fulkerson方法依赖于三种重要思想,这三个思想就是在上一篇网络流基础中提到的:残留网络,增广路径和割。Ford-Fulkerson方法是一种迭代的方法。开始时,对所有的u,v∈V有f(u,v)=0,即初始状态时流的值为0。在每次迭代中,可通过寻找一条“增广路径”来增加流值。增广路径可以看成是从源点s到汇点t之间的一条路径,沿该路径可以压入更多的流,从而增加流的值。反复进行这一过程,直至增广路径都被找出来,根据最大流最小割定理,当不包含增广路径时,f是G中的一个最大流。在算法导论中给出的Ford-Fulkerson实现代码如下:

     FORD_FULKERSON(G,s,t)
     1   for each edge(u,v)∈E[G]
     2        do f[u,v] <— 0
     3            f[v,u] <— 0
     4   while there exists a path p from s to t in the residual network Gf
     5        do cf(p) <— min{ cf(u,v) : (u,v) is in p }
     6        for each edge(u,v) in p
     7             do f[u,v] <— f[u,v]+cf(p)         //对于在增广路径上的正向的边,加上增加的流
     8                  f[v,u] <— -f[u,v]                //对于反向的边,根据反对称性求

     第1~3行初始化各条边的流为0,第4~8就是不断在残留网络Gf中寻找增广路径,并沿着增广路径的方向更新流的值,直到找不到增广路径为止。而最后的最大流也就是每次增加的流值cf(p)之和。在实际的实现过程中,我们可以对上述代码做些调整来达到更好的效果。如果我们采用上面的方法,我们就要保存两个数组,一个是每条边的容量数组c,一个就是上面的每条边的流值数组f,在增广路径中判断顶点u到v是否相同时我们必须判断c[u][v]-f[u][v]是否大于0,但是因为在寻找增广路径时是对残留网络进行查找,所以我们可以只保存一个数组c来表示残留网络的每条边的容量就可以了,这样我们在2~3行的初始化时,初始化每条边的残留网络的容量为G的每条边的容量(因为每条边的初始流值为0)。而更新时,改变7~8行的操作,对于在残留网络上的边(u,v)执行c[u][v]-=cf(p),而对其反向的边(v,u)执行c[v][u]+=cf(p)即可。

      现在剩下的最关键问题就是如何寻找增广路径。而Ford-Fulkerson方法的运行时间也取决于如何确定第4行中的增广路径。如果选择的方法不好,就有可能每次增加的流非常少,而算法运行时间非常长,甚至无法终止。对增广路径的寻找方法的不同形成了求最大流的不同算法,这也是Ford-Fulkerson被称之为“方法”而不是“算法”的原因。下面将给出Ford-Fulkerson方法的具体实现细节:

int c[MAX][MAX];  //残留网络容量
int pre[MAX];  //保存增广路径上的点的前驱顶点
bool visit[MAX];

int Ford_Fulkerson(int src,int des,int n){   //src:源点 des:汇点 n:顶点个数
     int i,_min,total=0;
     while(true){
         if(!Augmenting_Path(src,des,n))return total; //如果找不到增广路就返回,在具体实现时替换函数名
         _min=(1<<30);
         i=des;
         while(i!=src){   //通过pre数组查找增广路径上的边,求出残留容量的最小值
             if(_min>c[pre[i]][i])_min=c[pre[i]][i];
             i=pre[i];
         }
         i=des;
         while(i!=src){    //再次遍历,更新增广路径上边的流值
             c[pre[i]][i]-=_min;
             c[i][pre[i]]+=_min;
             i=pre[i];
         }
         total+=_min;     //每次加上更新的值
     }
}

Edmonds-Karp算法实际上就是采用广度优先搜索来实现对增广路径的p的计算,代码如下:

bool Edmonds_Karp(int src,int des,int n){
     int v,i;
     for(i=0;i<n;i++)visit[i]=false;
     front=rear=0;     //初始化
     que[rear++]=src;
     visit[src]=true;
     while(front!=rear){     //将源点进队后开始广搜的操作
         v=que[front++]; 
         
//这里如果采用邻接表的链表实现会有更好的效率,但是要注意(u,v)或(v,u)有任何一条
         //边存在于原网络流中,那么邻接表中既要包含(u,v)也要包含(v,u)

         for(i=0;i<n;i++){ 
             if(!visit[i]&&c[v][i]){  
//只有残留容量大于0时才存在边
                 que[rear++]=i;
                 visit[i]=true;
                 pre[i]=v;
                 if(i==des)return true;   //如果已经到达汇点,说明存在增广路径返回true
             }
         }
     }
     return false;
}


 

网络流Dinic算法详解及模板

分类: 图论   628人阅读  评论(0)  收藏  举报

目录(?)[+]

/*****以下来自<<浅谈基于分层思想的网络流算法>> 王欣*****/

层次图




短路增值算法(MPLA)

算法流程

Ford_Fulkerson算法,EK算法,DInic算法_第1张图片

汇点不在层次图内意味着在剩余图中不存在一条从源点到汇点的路径,即没有增广路。

在程序实现的时候,层次图并不用被“建”出来,我们只需对每个顶点标记层次,增广的时候,判断边是否满足level(u) +1= level(v)这一约束即可。

最大流模板【EdmondsKarp算法,简称EK算法,O(m^2n)】

  (2011-05-26 23:28:50)
转载
标签: 

it

分类: 图论

   因为是初学教程,所以我会尽量避免繁杂的数学公式和证明。也尽量给出了较为完整的代码。

本文的目标群体是网络流的初学者,尤其是看了各种NB的教程也没看懂怎么求最大流的小盆友们。本文的目的是,解释基本的网络流模型,最基础的最大流求法,即bfs找增广路法,也就是EK法,全名是Edmond-Karp,其实我倒是觉得记一下算法的全名和来历可以不时的拿出来装一装。

    比如说这个,EK算法首先由俄罗斯科学家Dinic在1970年提出,没错,就是dinic算法的创始人,实际上他提出的也正是dinic算法,在EK的基础上加入了层次优化,这个我们以后再说,1972年Jack Edmonds和Richard Karp发表了没有层次优化的EK算法。但实际上他们是比1790年更早的时候就独立弄出来了。

    你看,研究一下历史也是很有趣的。

    扯远了,首先来看一下基本的网络流最大流模型。

    有n个点,有m条有向边,有一个点很特殊,只出不进,叫做源点,通常规定为1号点。另一个点也很特殊,只进不出,叫做汇点,通常规定为n号点。每条有向边上有两个量,容量和流量,从i到j的容量通常用c[I,j]表示,流量则通常是f[I,j]。通常可以把这些边想象成道路,流量就是这条道路的车流量,容量就是道路可承受的最大的车流量。很显然的,流量<=容量。而对于每个不是源点和汇点的点来说,可以类比的想象成没有存储功能的货物的中转站,所有”进入”他们的流量和等于所有从他本身”出去”的流量。

    把源点比作工厂的话,问题就是求从工厂最大可以发出多少货物,是不至于超过道路的容量限制,也就是,最大流。

    比如这个图。每条边旁边的数字表示它的容量。

 

Ford_Fulkerson算法,EK算法,DInic算法_第2张图片



    下面我们来考虑如何求最大流。

    首先,假如所有边上的流量都没有超过容量(不大于容量),那么就把这一组流量,或者说,这个流,称为一个可行流。一个最简单的例子就是,零流,即所有的流量都是0的流。

我们就从这个零流开始考虑,假如有这么一条路,这条路从源点开始一直一段一段的连到了汇点,并且,这条路上的每一段都满足流量<容量,注意,是严格的<,而不是<=。那么,我们一定能找到这条路上的每一段的(容量-流量)的值当中的最小值delta。我们把这条路上每一段的流量都加上这个delta,一定可以保证这个流依然是可行流,这是显然的。

    这样我们就得到了一个更大的流,他的流量是之前的流量+delta,而这条路就叫做增广路。

    我们不断地从起点开始寻找增广路,每次都对其进行增广,直到源点和汇点不连通,也就是找不到增广路为止。当找不到增广路的时候,当前的流量就是最大流,这个结论非常重要。

寻找增广路的时候我们可以简单的从源点开始做bfs,并不断修改这条路上的delta量,直到找到源点或者找不到增广路。

这里要先补充一点,在程序实现的时候,我们通常只是用一个c数组来记录容量,而不记录流量,当流量+1的时候,我们可以通过容量-1来实现,以方便程序的实现。

 

Bfs过程的半伪代码:下面另给一个C++版的模板

int BFS()
{
    int i,j,k,v,u;
    memset(pre,-1,sizeof(pre));
    for(i=1;i<=n;++i)flow[i]=max_int;
    queue<int>que;
    pre[start]=0;
    que.push(start);
    while(!que.empty())
    {
        v=que.front();
        que.pop();
        for(i=1;i<=n;++i)
        {
            u=i;
            if(u==start||pre[u]!=-1||map[v][u]==0)continue;
            pre[u]=v;
            flow[u]=MIN(flow[v],map[v][u]);
            que.push(u);
        }
    }
    if(flow[end]==max_int)return -1;
    return flow[end];
}

但事实上并没有这么简单,上面所说的增广路还不完整,比如说下面这个网络流模型。

Ford_Fulkerson算法,EK算法,DInic算法_第3张图片


我们第一次找到了1-2-3-4这条增广路,这条路上的delta值显然是1。于是我们修改后得到了下面这个流。(图中的数字是容量)

Ford_Fulkerson算法,EK算法,DInic算法_第4张图片


这时候(1,2)和(3,4)边上的流量都等于容量了,我们再也找不到其他的增广路了,当前的流量是1。

但这个答案明显不是最大流,因为我们可以同时走1-2-4和1-3-4,这样可以得到流量为2的流。

那么我们刚刚的算法问题在哪里呢?问题就在于我们没有给程序一个”后悔”的机会,应该有一个不走(2-3-4)而改走(2-4)的机制。那么如何解决这个问题呢?回溯搜索吗?那么我们的效率就上升到指数级了。

而这个算法神奇的利用了一个叫做反向边的概念来解决这个问题。即每条边(I,j)都有一条反向边(j,i),反向边也同样有它的容量。

我们直接来看它是如何解决的:

 

在第一次找到增广路之后,在把路上每一段的容量减少delta的同时,也把每一段上的反方向的容量增加delta。即在Dec(c[x,y],delta)的同时,inc(c[y,x],delta)

我们来看刚才的例子,在找到1-2-3-4这条增广路之后,把容量修改成如下

Ford_Fulkerson算法,EK算法,DInic算法_第5张图片


这时再找增广路的时候,就会找到1-3-2-4这条可增广量,即delta值为1的可增广路。将这条路增广之后,得到了最大流2。

Ford_Fulkerson算法,EK算法,DInic算法_第6张图片

那么,这么做为什么会是对的呢?我来通俗的解释一下吧。

事实上,当我们第二次的增广路走3-2这条反向边的时候,就相当于把2-3这条正向边已经是用了的流量给”退”了回去,不走2-3这条路,而改走从2点出发的其他的路也就是2-4。(有人问如果这里没有2-4怎么办,这时假如没有2-4这条路的话,最终这条增广路也不会存在,因为他根本不能走到汇点)同时本来在3-4上的流量由1-3-4这条路来”接管”。而最终2-3这条路正向流量1,反向流量1,等于没有流量。

这就是这个算法的精华部分,利用反向边,使程序有了一个后悔和改正的机会。而这个算法和我刚才给出的代码相比只多了一句话而已。
#include<iostream>
#include<queue>
using namespace std;
const int maxn=205;
const int inf=0x7fffffff;

int r[maxn][maxn]; //残留网络,初始化为原图
bool visit[maxn];
int pre[maxn];
int m,n;

bool bfs(int s,int t)  //寻找一条从s到t的增广路,若找到返回true
{
    int p;
    queue<int > q;
    memset(pre,-1,sizeof(pre));
    memset(visit,false,sizeof(visit));

    pre[s]=s;
    visit[s]=true;
    q.push(s);
    while(!q.empty())
    {
        p=q.front();
        q.pop();
        for(int i=1;i<=n;i++)
        {
            if(r[p][i]>0&&!visit[i])
            {
                pre[i]=p;
                visit[i]=true;
                if(i==t) return true;
                q.push(i);
            }
        }
    }
    return false;
}

int EdmondsKarp(int s,int t)
{
   int flow=0,d,i;
   while(bfs(s,t))
   {
       d=inf;
       for(i=t;i!=s;i=pre[i])
           d=d<r[pre[i]][i]? d:r[pre[i]][i];
       for(i=t;i!=s;i=pre[i])
       {
           r[pre[i]][i]-=d;
           r[i][pre[i]]+=d;
       }
       flow+=d;
   }
   return flow;
}


int main()
{
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        int u,v,w;
        memset(r,0,sizeof(r));///
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            r[u][v]+=w;
        }
        printf("%d\n",EdmondsKarp(1,n));
    }
    return 0;
}




Dinic算法

Dinic算法的思想也是分阶段地在层次图中增广。

它与最短路径增值算法不同之处是:在Dinic算法中,我们用一个dfs过程代替多次bfs来寻找阻塞流。下面给出其算法步骤:

算法流程

Ford_Fulkerson算法,EK算法,DInic算法_第7张图片

增广过程图解

Ford_Fulkerson算法,EK算法,DInic算法_第8张图片

Ford_Fulkerson算法,EK算法,DInic算法_第9张图片

伪代码描述

Ford_Fulkerson算法,EK算法,DInic算法_第10张图片

在程序里,p表示找到的增广路径,p.top为路径中的最后一个顶点。一开始,p中只有源点。
整个While循环分为2个操作。如果p的最后一个顶点为汇点,也就是说找到了增广路,那么对p增广,注意到增广后一定有一条或多条p中的边被删除了。这时,我们使增广路径后退至p中从源点可到达的最后一个顶点。
如果p的最后一个顶点不为汇点,那么观察最后那个的顶点u 。若在层次图中存在从u连出的一条边,比如(u,v),我们就将顶点v放入路径p中,继续dfs遍历;否则,点u对之后的dfs遍历就没有用了,我们将点u以及层次图中连到u的所有边删除,并且在p中后退一个点。
Dfs过程将会不断重复这2个操作,直到从源点连出的边全部被删除为止。

/*****以上来自<<浅谈基于分层思想的网络流算法>> 王欣*****/

模板

[cpp]  view plain copy
  1. /* filename :network_flow_Dinic.cpp 
  2.  * author :AntiheroChen 
  3.  * Description :It's a Dinic solution for the network flow prblem. 
  4.  * Complexity :O(V^2*E) always below this. 
  5.  * Version :1.00 
  6.  * History : 
  7.  * 1)2012/02/29 first release. 
  8.  */  
  9. #include <iostream>  
  10. #include <cstdio>  
  11. #include <cstring>  
  12. #include <cstdlib>  
  13. using namespace std;  
  14. const int maxn=1000+5, bign=1000000000;  
  15. int M, n, m, source, sink, c[maxn][maxn], cnt[maxn];  
  16.   
  17.   
  18. /* The arc of the flow network.*/  
  19. struct Pool  
  20. {  
  21.     int next, t, c;  
  22. } edge[maxn*maxn<<1];  
  23.   
  24.   
  25. /* The point of the flow network.*/  
  26. struct Point  
  27. {  
  28.     int son, cur, pre, lim, d;  
  29. } a[maxn];  
  30.   
  31.   
  32. /* Prepare for the algorithm.*/  
  33. void initialize()  
  34. {  
  35.     M=1;  
  36.     memset(c, 0, sizeof (c));  
  37.     memset(a, 0, sizeof (a));  
  38.     memset(cnt, 0, sizeof (cnt));  
  39. }  
  40.   
  41.   
  42. /* Add an arc to the flow network.*/  
  43. void add(int x, int y, int z)  
  44. {  
  45.     edge[++M].t=y;  
  46.     edge[M].c=z;  
  47.     edge[M].next=a[x].son;//相当于pool的head数组  
  48.     a[x].son=M;  
  49. }  
  50.   
  51.   
  52. /* Read the data and make it the right format.*/  
  53. void input()  
  54. {  
  55.     scanf("%*s%*d%d%d%d%d", &n, &m, &source, &sink);  
  56.     initialize();  
  57.     int x, y, z;  
  58.     while (m--)  
  59.         scanf("%d%d%d", &x, &y, &z), c[x][y]+=z;  
  60.     for (int i=0; i<n; i++)  
  61.         for (int j=0; j<n; j++)  
  62.             if (c[i][j])add(i, j, c[i][j]), add(j, i, c[j][i]), c[j][i]=0;  
  63. }  
  64.   
  65.   
  66. int que[maxn], fi, la;  
  67. bool vis[maxn];  
  68.   
  69.   
  70. /* Build the hierarchical graph for the algorithm*/  
  71. bool build()  
  72. {  
  73.     memset(vis, 0, sizeof (vis));  
  74.     que[fi=la=0]=sink;//reverse  
  75.     a[sink].d=0, a[sink].cur=a[sink].son, vis[sink]=true;  
  76.     while (fi<=la)  
  77.     {  
  78.         int v=que[fi++];  
  79.         for (int now=a[v].son, u; u=edge[now].t, now; now=edge[now].next)  
  80.             if (edge[now^1].c&&!vis[u])//BFS来分层,这里和EK相同  
  81.             {//倒着BFS的话,当然引用的还是对侧边,即正向边  
  82.                 a[u].d=a[v].d+1;//越向前标号渐大  
  83.                 a[u].cur=a[u].son;//cur指向头  
  84.                 vis[u]=true;//已遍历  
  85.                 que[++la]=u;//入队  
  86.             }  
  87.         if (vis[source])return true;//层次图向前已经扩展到原点  
  88.     }  
  89.     return false;  
  90. }  
  91.   
  92.   
  93. /*Use the Dinic algorithm to calculate the max flow.*/  
  94. int MaxFlow()  
  95. {  
  96.     int u, v, now, ret=0;  
  97.     while (build())  
  98.     {  
  99.         a[u=source].lim=bign;  
  100.         while (true)  
  101.         {  
  102.             for (now=a[u].cur; v=edge[now].t, now; now=edge[now].next)//cur优化  
  103.                 if (edge[now].c&&a[u].d==a[v].d+1)break;//找到了一个子节点属于层次图  
  104.             if (now)  
  105.             {  
  106.                 a[u].cur=edge[now].next;//下一次从这一条边的下一条边开始dfs  
  107.                 a[v].pre=now;//指向v的边的指针  
  108.                 a[v].lim=min(a[u].lim, edge[now].c);///更新到此处为止流的上限  
  109.                 if ((u=v)==sink)//如果已经找到了一条增广路(走到了尽头)  
  110.                 ///注意这个地方借判断语句, 将u下移, 便于判断为否的时候回到上面进入下一层!  
  111.                 {//进行增广  
  112.                     do  
  113.                     {  
  114.                         edge[a[u].pre].c-=a[sink].lim;  
  115.                         edge[a[u].pre^1].c+=a[sink].lim;//这两句和Edmonds-Karp是一样的,增广  
  116.                         u=edge[a[u].pre^1].t;//找前驱~!  
  117.                     } while (u!=source);  
  118.                     ret+=a[sink].lim;//增广完毕之后累加新找到的流  
  119.                 }//否则(没走到尽头)继续向下DFS  
  120.             }  
  121.             else//没有子节点属于层次图  
  122.             {  
  123.                 if (u==source)break;//已经退到了源,则已找到最大流,算法结束  
  124.                 a[u].cur=now;//=0,此节点被废弃,子代亦然  
  125.                 u=edge[a[u].pre^1].t;//根据反向边找到前驱~!  
  126.             }  
  127.         }  
  128.     }  
  129.     return ret;  
  130. }  
  131.   
  132.   
  133. int main()  
  134. {  
  135.     int total;  
  136.     scanf("%d", &total);  
  137.     while (total--)  
  138.     {  
  139.         input();  
  140.         printf("%d\n", MaxFlow());  
  141.     }  
  142.     return 0;  
  143. }  


你可能感兴趣的:(图论)