网络流学习笔记（4）：Dinic 算法详解+代码模板

之前介绍过求解最大流的一种方法：Ford - Fulkerson 算法，大多数情况下这个算法已经足够高效了，但当顶点数或最大流流量非常大时，这个算法就显得不够快了。事实上，与其守着一个算法过日子，不如多学几个，万一用到了就赚了，介绍一下实现起来比较简单，实际运行也比较快速的 Dinic 算法。

Ford-Fulkerson 算法是通过深度优先搜索寻找增广路，并沿着它增广。与之相对，Dinic 算法总是寻找最短的增广路，并沿着它增广。

因为最短增广路的长度在增广过程中始终不会变短，所以无需每次都通过宽度预先搜索来寻找最短增广路。我们可以先进行一次宽度优先搜索，然后考虑由近距离顶点指向远距离顶点的边所组成的分层图，在上面进行深度优先搜索寻找最短增广路。简单来说

我们先用 BFS 遍历所有的点，目的是记录下每个节点的深度，即从 s 到每个节点的距离。（这个数组之后会有用处）注意这个过程中，已满流的边无需访问。

然后是一遍 DFS，也是从 s 出发。我们不走 " 同级 " 的，即深度必须是递增的序列（用到之前的数组），否则会走 " 回头路 "（会慢）。对于一个节点，需要将其上级分配过来的流量，分配给下级，注意不能超过下级的容量。如果给了下级流量，却没有用，说明下次无需访问这个节点了。这样每走到 t，就相当于找到一条增广链了，可以退回去接着找。

重复以上操作（一遍 BFS＋DFS），即可求出最大流。该算法在实
际应用中速度非常快，很多时候即便图的规模比较大也没有问题。

引用别人家的图片来说明Dinic为什么高效
https://blog.csdn.net/zhouzi2018/article/details/81865934?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task
对如下的一个图

很容易可以得到，最大流是2*999，但是如果我们执行Ford - Fulkerson 算法，程序很有可能呈现出下面一个状态

而下一次增广时


这个过程非常的低效，而对于Dinic算法而言，我们使用了分层图，保证在寻找增广路径的过程中，下一个点一定出现在下一层，因此很快就能得到答案。

代码模板

#include<iostream>
#include<cmath>
#include<string.h>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>
#include<iomanip>
using namespace std;

#define ll long long
#define vec vector<ll>
#define arr vector<vec>
#define inf 19270817
#define MaxV 1000

struct edge {
	ll to, cap, rev;//重点，容量，反向边
	edge(ll a, ll b, ll c) { to = a, cap = b, rev = c; }
};
vector<edge> G[MaxV];
ll level[MaxV];//i节点对应的层次
ll iter[MaxV];//当前弧，在其之前的边已经没有用了。

void addEdge(ll from, ll to, ll cap) {
	G[from].push_back(edge(to, cap, G[to].size()));
	G[to].push_back(edge(from, 0, G[from].size() - 1));
}

// 通过BFS计算从源点出发的距离标号
void bfs(int s) {
	memset(level, -1, sizeof(level));
	queue<ll> que; level[s] = 0; que.push(s);
	while (!que.empty()) {
		ll v = que.front; que.pop();
		for (unsigned i = 0; i < G[v].size(); i++) {
			edge & e = G[v][i];
			if (e.cap > 0 && level[e.to] == -1) {//不是反向边，还没有判断过，level也起visited的作用
				level[e.to] = level[v] + 1;
				que.push(e.to);
			}
		}
	}
}

// 通过DFS寻找增广路
ll dfs(ll v, ll t, ll f) {
	if (v == t) return f;
	//&i 是为了不断修改iter[v]的值，避免对无用边进行检查
	for (ll &i = iter[v]; i < G[v].size(); i++) {
		edge & e = G[v][i];
		if (e.cap > 0 && level[e.to] > level[v]) {
			ll d = dfs(e.to, t, min(e.cap, f));
			if (d > 0) {
				e.cap -= d; 
				G[e.to][e.rev].cap += d;
				return d;
			}
		}
	}
	return 0;
}

ll maxFlow(ll s, ll t) {
	ll flow = 0;
	while (1) {
		bfs(s);
		if (level[t] < 0) return flow;//压根不连通
		memset(iter, 0, sizeof(iter));
		ll f;
		while ((f = dfs(s, t, inf) > 0)) flow += f;
	}
}