最大网络流算法

1、网络流基础

2、FF算法实现

3、 ff算法c++实现

 1.流网络G=(V,E)是一个有向图，其中每条边(u,v)∈E均有一个非负容量c(u,v)>=0。如果(u,v)不属于E，则假定c(u,v)=0。流网络中有两个特别的顶点：源点s和汇点t。下图展示了一个流网络的实例（其中斜线左边的数字表示实际边上的流，右边的数字表示边的最大容量）：

                              

      对一个流网络G=(V,E)，其容量函数为c，源点和汇点分别为s和t。G的流f满足下列三个性质：
      容量限制：对所有的u，v∈V，要求f(u,v)<=c(u,v)。
      反对称性：对所有的u，v∈V，要求f(u,v)=-f(v,u)。
      流守恒性：对所有u∈V-{s,t}，要求∑f(u,v)=0 (v∈V)。

      容量限制说明了从一个顶点到另一个顶点的网络流不能超过设定的容量，就好像是一个管道只能传输一定容量的水，而不可能超过管道体积的限制；反对称性说明了从顶点u到顶点v的流是其反向流求负所得，就好像是当参考方向固定后，站在不同的方向看，速度一正一负；而流守恒性说明了从非源点或非汇点的顶点出发的点网络流之和为0，这有点类似于基尔霍夫电流定律，且不管什么是基尔霍夫电流定律，通俗的讲就是进入一个顶点的流量等于从该顶点出去的流量，如果这个等式不成立，必定会在该顶点出现聚集或是枯竭的情况，而这种情况是不应该出现流网络中的，所以一般的最大流问题就是在不违背上述原则的基础上求出从源点s到汇点t的最大的流量值，显然这个流量值应该定义为从源点出发的总流量或是最后聚集到t的总流量，即流f的值定义为|f|=∑f(s,v) (v∈V)。

---

      2.在求解最大流的问题前，必须对三个概念有所了解：残留网络，增广路径和割。下面先给出这三个概念的基本内容。
      a.在给定的流网络G=(V,E)中，设f为G中的一个流，并考察一对顶点u，v∈V，在不超过容量c(u,v)的条件下，从u到v之间可以压入的额外网络流量，就是(u,v)的残留容量，就好像某一个管道的水还没有超过管道的上限，那么就这条管道而言，就一定还可以注入更多的水。残留容量的定义为：cf(u,v)=c(u,v)-f(u,v)。而由所有属于G的边的残留容量所构成的带权有向图就是G的残留网络。下图就是上面的流网络所对应的残留网络：

                              

      残留网络中的边既可以是E中边，也可以是它们的反向边。只有当两条边(u,v)和(v,u)中，至少有一条边出现在初始网络中时，边(u,v)才会出现在残留网络中。下面是一个有关残留网络的定理，若f是G中的一个流，Gf是由G导出的残留网络，f'是Gf中的一个流，则f+f'是G中一个流，且其值|f+f'|=|f|+|f'|。证明时只要证明f+f'这个流在G中满足之前所讲述的三个原则即可。在这里只给出理解性的证明，可以想象如果在一个管道中流动的水的总流量为f，而在该管道剩余的流量中存在一个流f'可以满足不会超过管道剩余流量的最大限，那么将f和f'合并后，也必定不会超过管道的总流量，而合并后的总流量值也一定是|f|+|f'|。

      b.增广路径p为残留网络Gf中从s到t的一条简单路径。根据残留网络的定义，在不违反容量限制的条件下，G中所对应的增广路径上的每条边(u,v)可以容纳从u到v的某额外正网络流。而能够在这条路径上的网络流的最大值一定是p中边的残留容量的最小值。这还是比较好理解的，因为如果p上的流大于某条边上的残留容量，必定会在这条边上出现流聚集的情况。所以我们将最大量为p的残留网络定义为：cf(p)=min{cf(u,v) | (u,v)在p上}。而结合之前在残留网络中定理，由于p一定是残留网络中从s到t的一条路径，且|f'|=cf(p)，所以若已知G中的流f，则有|f|+|cf(p)|>|f|且|f|+|cf(p)|不会超过容量限制。

      c.流网络G(V,E)的割(S,T)将V划分成为S和T=V-S两部分，使得s∈S，t∈T。如果f是一个流，则穿过割(S,T)的净流被定义为f(S,T)=∑f(x,y) (x∈S,y∈T)，割(S,T)的容量为c(S,T)。一个网络的最小割就是网络中所有割中具有最小容量的割。设f为G中的一个流，且(S,T)是G中的一个割，则通过割(S,T)的净流f(S,T)=|f|。因为f(S,T)=f(S,V)-f(S,S)=f(S,V)=f(s,V)+f(S-s,V)=f(s,V)=|f|（这里的公式根据f(X,Y)=∑f(x,y) (x∈X,y∈Y)的定义，以及前面的三个限制应该还是可以推出来的，这里就不细讲了）。有了上面这个定理，我们可以知道当把流不断增大时，流f的值|f|不断的接近最小割的容量直到相等，如果这时可以再增大流f，则f必定会超过某个最小的割得容量，则就会存在一个f(S,T)<=c(S,T)<|f|，显然根据上面的定理这是不可能。所以最大流必定不超过网络最小割的容量。

      综合上面所讲，有一个很重要的定理：最大流最小割定理

      如果f是具有源s和汇点t的流网络G=(V,E)中的一个流，则下列条件是等价的：
      1) f是G中一个最大流。
      2) 残留网络Gf不包含增广路径。
      3) 对G的某个割(S,T)，有|f|=c(S,T)。

      到这里为止网络流的基本知识已经讲的差不多了，下一篇中我将给出实现求解网络最大流基本思想和实现的几种算法。

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

      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)即可。

//应用：:http://acm.pku.edu.cn/JudgeOnline/problem?id=1273 

#include<iostream>
#include<fstream>
#include<queue>
using namespace std;

int N,M;  //边数，顶点数
const int maxN=201;
bool visited[maxN];
int pre[maxN];			//前驱节点
int c[maxN][maxN];
int ans;

void Ford_Fulkerson()
{
	while(1)
	{
		queue<int> q;
		memset(visited,0,sizeof(visited));
		memset(pre,-1,sizeof(pre));
		q.push(0);			//第一个定点入队
		visited[0]=1;		//打上已经被访问的标记
		while(!q.empty())
		{
			int now=q.front();
			if(now==M-1)		//注意：找到一条增广路径后就跳出循环
				break;
			q.pop();
			for(int i=0;i<M;i++)
			{
				if(c[now][i]&&!visited[i])
				{
					q.push(i);
					visited[i]=1;
					pre[i]=now;
				}
			}
		}
		if(!visited[M-1])
			break;
		int min=0x7fffffff;
		for(int i=M-1;i>0;i=pre[i])    //注意For循环的条件
		{
			if(c[pre[i]][i]<min)
				min=c[pre[i]][i];
		}

		for(int i=M-1;i>0;i=pre[i])
		{
			c[pre[i]][i]-=min;     //前向弧增加min
			c[i][pre[i]]+=min;		//后向弧减小min
		}
		ans+=min;
	}
}


int main()
{
	//ifstream cin;
	//cin.open("input.txt");
	while(cin>>N>>M)
	{
		int v,s,w;
		ans=0;
		memset(c,0,sizeof(c));
		for(int i=0;i<N;i++)
		{
			cin>>v>>s>>w;
			c[v-1][s-1]+=w;
		}

		//cin.close();

		Ford_Fulkerson();
		cout<<ans<<endl;
	}
	return 0;
}