网络流（最大流和最小费用流）

几个月前学过，然而一下就忘记了，于是决定系统的复习一下。

关于网络流各路神犇早已有很好的讲解，于是我就整理一下（其实我是蒟蒻，看到的果断关掉吧）

http://blog.csdn.net/leolin_/article/details/7202691

残余网络： 两个点之间有一个流的限制，那么假如有一个流流过，那么残余网络记录的是在进行几次操作之后，两点间还可以通过多少。

增广路径：（引用他人的话）假如有这么一条路，这条路从源点开始一直一段一段的连到了汇点，并且，这条路上的每一段都满足流量<容量，注意，是严格的<,而不是<=。那么，我们一定能找到这条路上的每一段的(容量-流量)的值当中的最小值delta。我们把这条路上每一段的流量都加上这个delta，一定可以保证这个流依然是可行流。这样我们就得到了一个更大的流，他的流量是之前的流量+delta，而这条路就叫做增广路。

最大流最小割定理：一个流是最大流，当且仅当它的残留网络不包含增广路径。

割：http://blog.csdn.net/kk303/article/details/6728400

    所谓网络流的割就是将点划分为连到S与连到T的两个点集合.....割就是这两个点集相连的边.....但注意...割的容量只记从S点集到T点集的....T点集到S点集的不算...所以割的容量等于这从S点集到T点集所有边的容量之和...
    而网络流的最小割就是这些割中容量最小的...

c[][]残余网络

反向边：（ 最难理解的是加反向边）比如从u到v流过x，那么c[u][v]-=x，c[v][u]+=x

讲的精简点，反向边的作用是给反向边的作用就是给程序一个可以后悔的机会 ，细细品味吧

1、Ford-Fulkerson算法 

不断寻找增光路。

 Ford-Fulkerson算法在实际中并不常用，但是它提供了一种思想：先找到一条从源点到汇点的增广路径，这条路径的容量是其中容量最小的边的容量。然后，通过不断找增广路，一步步扩大流量，当找不到增广路时，就得到最大流了（最大流最小割定理）。

寻找通路的时候可以用DFS，BFS最短路等算法。就这两者来说,BFS要比DFS快得多，但是编码量也会相应上一个数量级。

http://codevs.cn/problem/1993/

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <queue>
#include <cstring>
using namespace std;
int n,m,start,end,zgpath[210],map[210][210],flow[210];
queue<int>q;
int bfs(void){
	while(!q.empty())q.pop();
	memset(zgpath,-1,sizeof(zgpath));
	zgpath[start]=0,flow[start]=99999999;
	q.push(start);
	while(!q.empty()){
		int x=q.front();
		q.pop();
		if(x==end)break;
		for(int i=1;i<=m;i++){
			if(i!=start&&zgpath[i]==-1&&map[x][i]){
				flow[i]=flow[x]<map[x][i] ? flow[x] : map[x][i];
				q.push(i);
				zgpath[i]=x;
			}
		}
	}
	if(zgpath[end]==-1)return -1;
	return flow[end];
}

int zuidaliu(void){
	int ans_max=0,ans_;
	while((ans_=bfs())!=-1){
		ans_max+=ans_;
		int now=end;
		while(now!=start){
			int pre=zgpath[now];
			map[pre][now]-=ans_;
			map[now][pre]+=ans_;
			now=pre;
		}
	}
	return ans_max;
}
int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		int a,b,c;
		cin>>a>>b>>c;
		map[a][b]+=c;
	}
	start=1,end=m;
	cout<<zuidaliu();
	return 0;
}

2、压入重标记push_relabel算法O(VE)

Push-relabel用到一个很有趣的概念一Preflow(前置流)他允许流进的量比流出的量还要多，有水来就先流进来，流不出去再说。

Push-relabel算法的流程如下：  

1 )我们先假定一个高度函数 h ( u ) ，他代表u点的高度，只有

h ( u )比较高的点才能够将水流到h ( u )比较低的点；  

2 ) 在程序一开始的时候，让source node的高度是n ( node数) ，  其它点的高度都是 0 ，这样source node才有足够的高度可以流往其它地方 ；  

3 ) 然后， 让source node往其它所有跟他直接相邻的node ，都流水管宽度的水量 ( 流过去之后当然要计算剩下的网络情形,即计算 residual  edges(残留网络)

4 )对所有active node( 目前有水的 node )做 relabel（重标记）的动作：  在当某个node明明有水，但是他所连出去的所有对象的 h ( u ) 都比他还高， 则让他的h ( u ) 增加为至少有一条水管可以流出去的量，也就是让这个有水的 active node的高度变成比他连往的”高度最小的 n o d e ”+l ， ( 流过去之后还是要计算剩下的网络情形

5 )对所有可以做push（压入）动作的node做push的动作。  所谓的Push动作是指 ： 当某个node有水，并且他有可以流出去的边， 且他刚好比可以流出去的那个点高度高一点点 ( 高度恰好比他高 1 ) ，那就把某个node 的水流过去，要流多少呢?以下两者取 min。  流出去的水管的量( 也就是说，这个active node的水量很多，  足够把这条水管塞满( 饱和) ，这个时候就叫做saturating Push)（饱和压入）某个 n o d e 现在的水量( 这个 n o d e的水量不足以把流出去的这个水管填满，称作non saturating Push（不饱和压入）  

6 )重复Relabel和Push的工作，一直到没有active node为止，此时从source node所流出的总流量( P r e f l o w) ，就是这个图的最大流量。  

Push-relabel  algorithm 提供了最大流另一方向的思考，且就效率而言，Push -Relabel的复杂度为 o (vE )

这里以 POJ 1459为例

[cpp]  view plain copy

1. #define MIN INT_MIN  
2. #define MAX INT_MAX  
3. #define N 110  
4. int min(int a,int b){ return a>b?b:a;}  
5. int c[N][N];//残留容量  
6. int ef[N];//顶点余流  
7. int h[N];//顶点高度  
8. int n;  
9. int push_relabel(int s,int t){  
10.     int i,j;  
11.     int ans = 0;  
12.     memset(h,0,sizeof(h));  
13.     h[s] = t+1;//源点初始高度  
14.     memset(ef,0,sizeof(ef));  
15.     ef[s] = MAX;//源点初始余流  
16.     queue<int> qq;  
17.     qq.push(s);  
18.     while(!qq.empty()){  
19.         int u = qq.front();  
20.         qq.pop();  
21.         for(i=0;i<=t;i++){  
22.             int p;  
23.             int v = i;  
24.             if(c[u][v]<ef[u])p = c[u][v];  
25.             else p = ef[u];