网络流-最大流 EdmondKarp算法 详细讲解 以及java实现源代码

部分内容转载自：http://www.cnblogs.com/zsboy/archive/2013/01/27/2878810.html 点击打开链接

最大流的含义，就是说从源点到经过的所有路径的最终到达汇点的所有流量和。

1. EK算法的核心：

反复寻找源点s到汇点t之间的增广路径（路径上的最小边值就是可以用过路径的最大流量)，每找到一条路径,我们正向减去对应边的流量，并且反向增加流量（主要是因为路径是随机选取的，使用贪婪算法可能获取的是局部最优解，添加反向边可以解除原来的错误决定。如果要做到这个，我们需要记录路径中每个点的前驱结点），最后我们获得所有可以通过的路径的和就是所能够得到的最大流。

2.算法举例

举个例子吧（参考文章开始所给的网址内容）：求源点1，到汇点4的最大流





首先，我们找到第一条路径1-4 路径流为20



我们对应边需要减去流量，并且添加方向便1-4的流量

基于上一个图，我们继续查找从源点1到汇点4的路径。我们找到1-2-4 路径，流量为20，减去正向边，增加反向边



继续下一步，找到1-2-3-4路径，流量为10



这个就是最终的图，因为找不到1-4的路径了

3.算法分析

接下来，解释一下为什么需要添加方向边：




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





这时候(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这条增广路之后，把容量修改成如下



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





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

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

4.Java源代码

import java.util.*;

import junit.framework.Assert;
public class EdmodKarp {
	int maxdata=Integer.MAX_VALUE;
    int[][] capacity;
    int[] flow;
    int[] pre;
    int n;
    Queue <Integer> queue;
    public EdmodKarp(int[][] capacity)
    {
    	this.capacity=capacity;
    	this.n=capacity.length;
    	this.pre=new int
;
    }
    //广度优先遍历的查找一条src到des的路径
    int BFS(int src,int des)
    {
           int i;
           this.queue=new LinkedList<Integer>();
           this.flow=new int
;
           for(i=0;i<n;++i)
           {
             pre[i]=-1;
           }
           pre[src]=-2;
           flow[src]= maxdata;
           queue.add(src);
           while(!queue.isEmpty())
           {
             int index = queue.poll();
              if(index == des)            //找到了增广路径
                 break;
              for(i=0;i<n;++i)
            {
            	  //找到非源节点未被访问过的可达结点，计算其流量
                 if(i!=src && capacity[index][i]>0 && pre[i]==-1)
                 {
                      pre[i] = index; //记录前驱
                      flow[i] = Math.min(capacity[index][i],flow[index]);   //关键：迭代的找到增量
                      queue.add(i);
                 }
             }
         }
        if(pre[des]==-1)      //残留图中不再存在增广路径
             return -1;
         else
             return flow[des];
        
     }
    
    int maxFlow(int src,int des)
    {
        int increasement= 0;
         int sumflow = 0;
         while((increasement=BFS(src,des))!=-1)
        {
        	 
              int k = des;          //利用前驱寻找路径
              while(k!=src)
              {
                   int last = pre[k];
                   capacity[last][k] -= increasement; //改变正向边的容量
                   capacity[k][last] += increasement; //改变反向边的容量
                   k = last;
              }
              System.out.println("-------改变后---------");
              for(int j=0;j<n;j++)
              {
             	 for(int x=0;x<n;x++)
             	 {
             	       System.out.print("---"+capacity[j][x]);
             	 }
             	 System.out.println();
              }
             sumflow += increasement;
         }
        return sumflow;
    }
    
    public static void main(String args[])
    {
    	int[][] matrix=new int[4][4];
    	matrix[0][1]=4;
    	matrix[0][3]=2;
    	matrix[1][2]=3;
    	matrix[1][3]=2;
    	matrix[2][3]=1;
    	
    	EdmodKarp edm=new EdmodKarp(matrix);
    	System.out.println("-------初始化---------");
        for(int j=0;j<edm.n;j++)
        {
       	 for(int k=0;k<edm.n;k++)
       	 {
       	       System.out.print("---"+edm.capacity[j][k]);
       	 }
       	 System.out.println();
        }
    	int actual=edm.maxFlow(0,3);
    	int expected=5;
    	System.out.println("-------最终结果---------");
        for(int j=0;j<edm.n;j++)
        {
       	 for(int k=0;k<edm.n;k++)
       	 {
       	       System.out.print("---"+edm.capacity[j][k]);
       	 }
       	 System.out.println();
        }
    	Assert.assertEquals(expected, actual);
    }
    
}