最大流 Ford Fulkerson, EK, SAP

1. Ford-Fulkerson 方法中，有三个概念：剩余网络，增广路径， 割。称Ford-Fulkerson为方法而不是算法是因为它是一类算法的统称。

剩余网络，就是在原网络中增加反向边。 如果选择从点u到点v流过流量f，那从v到u就有容量为f的反向边。

反向边存在的意义是对已经选择的流“反悔”，如下图，如果第一次选择路径0-1-3-5，那第二次就没有路径可选了，此时流量为1。

如果存在反向边，那么第二次可以选择路径0-2-3-1-4-5，此时流量为2。

增广路径，就是在剩余网络中从源点到汇点的一条路径。

最大流最小割定理

令f为原网络中从s到t的流量，下面三个命题互相等价：

1. f是最大流

2. 剩余网络中没有增广路径

3. 原网络中存在一个割(S,T), 使得 |f| = c(S, T), 其中

Ford_Fulkerson_Method( G, s, t )

1. initialize flow f to 0

2. while there exist an augmenting path p in the residual network Gf

3.     augment flow f along p

4. return f

2. Edmonds-Karp算法

Ford-Fulkerson中存在的问题是，在最坏情况下，时间复杂度为O(E*F)，其中F为最大流。

解决方法是每次选择增广路径时都选最短路，这就是Edmonds-Karp算法。

3. SAP

每次选择最短路可以用bfs，但bfs很耗时。SAP (shortest augmenting path) 一开始使用bfs对每个点到汇点的距离进行标记，此后根据标记的距离进行dfs寻找一条最短路。例如最开始源点到汇点的最短距离为k，那dfs中下一步就寻找距离为k-1的点。

如果在某个点找不到可以往下走的点，那么就要更新这个点的距离，把它设为 min{ dis[i] } + 1，min{ dis[i] } 是在剩余网络中这个点的所有邻居中的最小距离。

GAP优化：如果在更新的过程中发现已经没有某个距离的点了，那就产生了一个gap，意味着已经没有增广路径了，算法可以提前结束。

模板（邻接表）：

#include <iostream>
#include <vector>
#include <queue>
#include <cstring>

using namespace std;

#define INF 0xFFFFF

const int MAXN = 400;

struct Edge
{
	int id;
	int cap;
	Edge( int _id, int _cap ) : id(_id), cap(_cap) { }
};

struct Node
{
	vector<Edge> next;
}node[MAXN];

int dis[MAXN];
int pre[MAXN];
int gap[MAXN+1];
int gapFlag;

void initNetwork()
{
	for( int i = 0; i < MAXN; i++ )
		node[i].next.clear();
}

void addEdge( int a, int b, int c )
{
	node[a].next.push_back( Edge(b, c) );
	node[b].next.push_back( Edge(a, 0) );
}

void updateEdge( int a, int b, int increment )
{
	for( int i = 0; i < node[a].next.size(); i++ )
	{
		if( node[a].next[i].id == b )
		{
			node[a].next[i].cap += increment;
			break;
		}
	}
}

void bfs( int sink ) // set the dis[]
{
	memset( dis, -1, sizeof(dis) );
	memset( gap, 0, sizeof(gap) );
	gapFlag = 0;
	queue<int> q;
	q.push( sink );
	dis[sink] = 0;
	gap[0] = 1;
	
	while( !q.empty() )
	{
		int cur = q.front();
		q.pop();
		
		for( int i = 0; i < node[cur].next.size(); i++ )
		{
			int nextId = node[cur].next[i].id;
			int cap = node[cur].next[i].cap;
			if( dis[nextId] == -1 && cap == 0 )
			{
				dis[nextId] = dis[cur] + 1;
				gap[ dis[nextId] ] += 1;
				q.push( nextId );
			}
		}
	}
}

int dfs( int cur, int sink, int &minFlow )
{
	if( cur == sink )
		return 1;
		
	for( int i = 0; i < node[cur].next.size(); i++ )
	{
		int nextId = node[cur].next[i].id;
		int cap = node[cur].next[i].cap;
		if( dis[nextId] == dis[cur]-1 && cap > 0 )
		{
			if( dfs( nextId, sink, minFlow ) == 1 )
			{
				minFlow = ( cap < minFlow )? cap : minFlow;
				pre[nextId] = cur;
				return 1;
			}
		}
	}
	
	// search failed, update dis[cur]
	gap[ dis[cur] ] -= 1;
	if( gap[dis[cur]] == 0 )
	{
		gapFlag = 1;
		return 0;
	}

	int minDis = MAXN;
	for( int i = 0; i < node[cur].next.size(); i++ )
	{
		int nextId = node[cur].next[i].id;
		int cap = node[cur].next[i].cap;
		if( cap > 0 && dis[nextId] != -1 && dis[nextId] < minDis )
			minDis = dis[nextId];
	}
	dis[cur] = minDis + 1;
	gap[ dis[cur] ] += 1;
	
	return 0;
}

int maxFlow( int source, int sink, int N )
{
	int flow = 0;
	
	bfs( sink ); // set the dis[]
	
	while( dis[source] < N )
	{
		int minFlow = INF;
		if( dfs( source, sink, minFlow ) == 1 )
		{
			int j = sink, k;
			while( j != source )
			{
				k = pre[j];
				updateEdge( k, j, -minFlow );
				updateEdge( j, k, minFlow );
				j = k;
			}
			flow += minFlow;
		}
		else if( gapFlag == 1 )
			break;
	}
	
	return flow;
}