网络流二·最大流最小割定理

对于一个网络流图G=(V,E)，其割的定义为一种点的划分方式：将所有的点划分为S和T=V-S两个部分，其中源点s∈S，汇点t∈T。

对于一个割(S,T)，我们定义净流f(S,T)表示穿过割(S,T)的流量之和，即：

f(S,T) = Σf(u,v) | u∈S,v∈T

举个例子(该例子选自算法导论)：

净流f = f(2,4)+f(3,4)+f(3,5) = 12+(-4)+11 = 19

同时我们定义割的容量C(S,T)为所有从S到T的边容量之和，即：

C(S,T) = Σc(u,v) | u∈S,v∈T

同样在上面的例子中，其割的容量为：

c(2,4)+c(3,5)=12+14=26

实际上对于任意一个割的净流f(S,T)总是和网络流的流量f相等。

对于任意一个割的净流f(S,T)一定是小于等于割的容量C(S,T)。那也即是，对于网络的任意一个流f一定是小于等于任意一个割的容量C(S,T)。

而在所有可能的割中，存在一个容量最小的割，我们称其为最小割。

这个最小割限制了一个网络的流f上界，所以有：

对于任一个网络流图来说，其最大流一定是小于等于最小割的。

利用上面讲的知识，我们可以推出一个最大流最小割定理：

对于一个网络流图G=(V,E)，其中有源点s和汇点t，那么下面三个条件是等价的：
1. 流f是图G的最大流
2. 残留网络Gf不存在增广路
3. 对于G的某一个割(S,T)，此时f = C(S,T)

首先证明1 => 2：

我们利用反证法，假设流f是图G的最大流，但是残留网络中还存在有增广路p，其流量为fp。则我们有流f'=f+fp>f。这与f是最大流产生矛盾。

接着证明2 => 3：

假设残留网络Gf不存在增广路，所以在残留网络Gf中不存在路径从s到达t。我们定义S集合为：当前残留网络中s能够到达的点。同时定义T=V-S。
此时(S,T)构成一个割(S,T)。且对于任意的u∈S,v∈T，有f(u,v)=c(u,v)。若f(u,v)0，s可以到达v，与v属于T矛盾。
因此有f(S,T)=Σf(u,v)=Σc(u,v)=C(S,T)。

最后证明3 => 1：

由于f的上界为最小割，当f到达割的容量时，显然就已经到达最大值，因此f为最大流。

这样就说明了为什么找不到增广路时，所求得的一定是最大流。

输入

第1行：2个正整数N,M。2≤N≤500，1≤M≤20,000。

第2..M+1行：每行3个整数u,v,c(u,v)，表示一条边(u,v)及其容量c(u,v)。1≤u,v≤N，0≤c(u,v)≤100。

给定的图中默认源点为1，汇点为N。可能有重复的边。

输出

第1行：2个整数A B，A表示最小割的容量，B表示给定图G最小割S集合的点数。

第2行：B个空格隔开的整数，表示S集合的点编号。

若存在多个最小割可以输出任意一个的解。

样例输入

6 7
1 2 3
1 3 5
2 4 1
3 4 2
3 5 3
4 6 4
5 6 2

样例输出

5 4
1 2 3 5

#include 
#include 
#include 
#include 
#include 
#define MAX 501
#define MAXCF 101
#define min(a,b) (a)>(b)?(b):(a)
using namespace std;

FILE *stream;
int cf[MAX][MAX];//存储图
int queue[MAX];//搜索队列
int path[MAX];//保存路径
int capacity[MAX];//流量数组，保存经过该点的最小流量
bool visited[MAX];//记录访问数组

int findAugmentPath(int T)
{
	int i = 0, tail = 0;
	memset(visited, 0, sizeof(visited));

	queue[tail] = 1;//将源点加入队列
	capacity[1] = MAXCF;
	visited[1] = true;
	while (i <= tail)
	{
		int u = queue[i];
		if (u == T)
			return capacity[T];//找到一条增广路径，返回该路径最小流量
		for (int v = 2; v <= T; v++)
		{
			if (!visited[v] && cf[u][v] > 0)
			{
				path[v] = u;
				capacity[v] = min(cf[u][v], capacity[u]);//记录路径上的最小残余流量
				visited[v] = true;
				tail++;
				queue[tail] = v;
			}
		}
		i++;
	}
	return 0;
}

void findS(int T, int maxFlow)
{
	int i = 0, tail = 0;
	int u, v;
	memset(visited, 0, sizeof(visited));

	queue[tail] = 1;//将源点加入队列

	visited[1] = true;
	while (i <= tail)
	{
		u = queue[i];
		for (v = 2; v < T; v++)
		{
			if (!visited[v] && cf[u][v] > 0)
			{
				visited[v] = true;
				tail++;
				queue[tail] = v;
			}
		}
		i++;
	}
	sort(queue, queue + tail + 1);
	cout << maxFlow << ' ' << tail + 1 << endl;
	cout << queue[0];
	for (i = 1; i <= tail; ++i)
		cout << ' ' << queue[i];
	cout << endl;
}

void modifyGraph(int T)
{
	int flow = capacity[T];
	int now = T;
	while (now != 1)
	{
		int fa = path[now];
		cf[fa][now] -= flow;
		cf[now][fa] += flow;
		now = fa;
	}
}

int main()
{
	int N, M;
	int i;
	int u, v;
	int temp;
	//freopen_s(&stream, "in.txt", "r", stdin);
	while (cin >> N >> M)
	{
		memset(cf, 0, sizeof(cf));
		for (i = 0; i < M; ++i)
		{
			cin >> u >> v >> temp;
			cf[u][v] += temp;
		}

		int maxFlow = 0;
		int delta = 0;
		while (delta = findAugmentPath(N))
		{
			maxFlow += delta;
			modifyGraph(N);
		}
		findS(N, maxFlow);
		//fclose(stdin);
		//system("pause");
	}
	return 0;
}