最大流问题：Ford-Fulkerson算法

最大流问题

网络中有两台计算机s和t，现在想从s传输数据到t。该网络中一共有N台计算机，其中一些计算机之间连有一条单向的通信电缆，每条通信电缆都有对应的1秒钟内所能传输的最大数据量。问在1秒钟s最多可以传输多少数据到t?

我们设c为每条边的容量，f为每条边的容量，s为源点，t为汇点

---

Ford-Fulkerson算法

1. 利用满足f(e)<c(e)的e或者满足f(e)>0的e对应的反向边rev(e),采用dfs寻找一条s到t的路径。

2. 如果不存在满足条件的路径，则结束。否则沿着该路径尽可能地增加流，返回第一步。

残留网络与增广路：
Ford-Fulkerson算法第一步中考虑的e:f(e)<c(e)的e或者满足f(e)>0的e对应的反向边rev(e)对应的图叫做残留网络，残留网络上的s-t路径被称为增广路。

那么上图网络对应求解步骤如下：

1. 初始形式：

3. 路径：s>1>3>t
路径最大流量：5
注：反向路径的权值与正向路径的f相等

4. 路径：s>1>2>t
路径最大流量：5

5. 路径：s>3>1>2>t
路径最大流量：1

---

Ford-Fulkerson算法代码：（图用邻接表表示）

#include<iostream>
#include<cstdlib>
#include<vector>
#include<algorithm>
#define INF 100
#define MAX 100
using namespace std;

struct edge {
	int to;
	int cap;
	//边的反向边的位置
	int rev;
};
vector<edge> G[MAX];
bool used[MAX];

void Add_edge(int from, int to, int cap) {
	//G[to].size()为rev边在G[to]向量中的位置
	edge e = { to, cap, G[to].size() };
	edge rev = { from, 0, G[from].size()};
	G[from].push_back(e);
	G[to].push_back(rev);
}

int dfs(int v, int t, int f) {
	if (v == t) return f;
	used[v] = 1;
	for (int i = 0; i < G[v].size(); i++) {
		edge &e = G[v][i];
		if (used[e.to] != 1 && e.cap > 0) {
			//d为所在路径的最大流
			int d = dfs(e.to, t, min(f, e.cap));
			if (d > 0) {
				//边容量-路径最大流
				e.cap -= d;
				//反相变+路径最大流
				G[e.to][e.rev].cap += d;
				return d;
			}
		}
	}
	return 0;
}

int max_flow(int s,int t) {
	int res = 0;
	for (;;) {
		memset(used, 0, sizeof(used));
		int f = dfs(s, t, INF);
		if (f == 0) return res;
		res += f;
	}
}


int main() {
	//边数
	int en; 
	int from, to, cap;
	cin >> en;
	for (int i = 0; i < en; i++) {
		cin >> from >> to >> cap;
		Add_edge(from, to, cap);
	}
	cout << max_flow(0, 4) << endl;
	system("pause");
}

对应例题中的结果：

---

Ford-Fulkerson算法可用最小割来证明：

图的割：指的是对于某个顶点集合S被包含于V，从S出发指向S外部的那些边的集合，记做割（S，V/S）。如果有s∈S，t∈V/S，此时的割称为s-t割。
最小割问题：给定网络，为保证没有从s到t的路径，需要删除的边的总量的最小值是多少？
这个图对应的最小割为11,与最大流相同