网络流——最大流

网络流的基本概念（参考算法导论）
流网络的的定义：
流网络是一个有向图；每条边都有一个权值；有两个特殊的节点，一个是结点s，另一个是汇点t；每个可行流都会从节点s流向节点t。
网络流的两个性质：

1. 容量限制：顾名思义就是每条边的流量不能超过边的最大容量。
2. 流量守恒：对于每个节点，流入的流量等于流出的流量。基尔霍夫水流定律

残存网络的定义：
在一个图中，如果确定了一个可行流，那么就存在唯一的残流网络与之对应。
残流网络的求法是：将图的正向边容量减去当前可行流的流量；同时，将每一个正向边建立一个与之对应的反向边，反向边的容量等于总容量减去流量。

最大流的算法：
这里介绍 Ford - Fulkerson 算法，该算法是基于残存网络的最大流算法。该算法是多次进行bfs，而每次bfs在残流网络中选出一条路径，并利用这条路径更新当前可行流。
当残流网络中不存在路径时，算法结束。
时间复杂度为O(nmm)

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define N 1010
int n, m;
int maxflow = 0;
int ne[N], val[N], to[N], h[N];
int cnt;

void add(int a, int b, int c)
{
	val[cnt] = c, to[cnt] = b, ne[cnt] = h[a], h[a] = cnt++;
	val[cnt] = 0, to[cnt] = a, ne[cnt] = h[b], h[b] = cnt++;
	***cnt为偶数时是正向边，cnt为奇数时是反向边。
}
int pre[210];  记录每个点的前驱节点
int flow[210];	 //流入每个点的最大流量
int inedge[210]; //记录通向每个点的边，与前驱节点配合还原路径。
int bfs(int start, int end)
{ //每次dfs只选择一条无分叉路
	int vis[210];
	memset(vis, 0, sizeof(vis));
	memset(flow, 0, sizeof(flow));
	queue<int> q;
	q.push(start);
	vis[start] = 1;
	flow[start] = 0x7fffffff;
	while (!q.empty())
	{
		int now = q.front();
		q.pop();
		if (now == end)
			return 1;
		for (int i = h[now]; i != -1; i = ne[i])
		{
			if (val[i] == 0)
				continue;
			int j = to[i];
			if (vis[j] == 0)
			{
				vis[j] = 1;
				pre[j] = now;
				inedge[j] = i;
				flow[j] = min(flow[now], val[i]);
				q.push(j);
			}
		}
	}
	return 0;
}
void update(int start, int end)
{
	int x = end;
	int f = flow[end];
	while (x != start)
	{
		int i = inedge[x];
		val[i] -= f;
		val[i ^ 1] += f;
		x = pre[x];
	}
	maxflow += f;
}
int main()
{
	cin >> n >> m;
	memset(h, -1, sizeof(h));
	for (int i = 1; i <= n; i++)
	{
		int a, b, c;
		cin >> a >> b >> c;
		add(a, b, c);
	}
	while (bfs(1, m))
	{
		update(1, m);
	}
	cout << maxflow << endl;
	return 0;
}

注：如果存在多个结点和汇点，就建立一个虚拟结点和虚拟汇点
费用流将bfs改为spfa即可