网络流学习笔记
网络流初步
一个网络\(G=(V,E)\)是一张有向图，图中每条有向边\((x,y) \in E\)都有一个给定的权值\(c(x,y)\)，称为边的容量。图中还有两个节点\(S\)和\(T\)，源点和汇点。
网络的流函数：\(f(x,y)\)具有一下特性：
1、容量限制，\(f(x,y)\le c(x,y)\)
2、斜对称，\(f(x,y) = -f(y,x)\)
3、流量守恒，\(x\neq S \And x \neq T,\sum_{(u,x)\in E}f(u,x)=\sum_{(x,v)\in E}f(x,v)\)
称\(f(x,y)\)为边的流量，则\(c(x,y)-f(x,y)\)为边的剩余流量，对于每条边，都有一个反向边，且反向边的流量是负流量。
最大流
使得整张网络的\(\sum_{(S,v)\in E}f(S,v\)最大的流函数被称为网络的最大流，此时流量被称为网络流的最大流量。
利用最大流求二分图匹配数量
可以新增一个S节点和一个T节点，从S出发连接每个左部节点，原来的每条边看做从左部节点连接到右部节点的有向边，从每个右部节点出发连T，所有边的容量都为1。求出的最大流量就是二分图最大匹配数。
在允许多重匹配的情况下，可以将从S到左部节点的边容量设为匹配上限，右部节点到T的边容量设为匹配上限。
Edmonds-Karp 增广路算法
若一条从源点到汇点的路径上，各边剩余容量都大于0，则这条路是一条增广路。那么可以利用这条增广路使网络流增大。
增广路就是每次BFS寻找增广路，找到流量为\(e\)的增广路之后，就更新路径上每条正向边剩余流量\(-e\)，反向边流量\(+e\)。直到找不到增广路，算法结束。
时间复杂度为\(O(nm^2)\)，实际使用远远达不到这个数值，可以处理\(10^3\)~\(10^4\)规模的图。
P3376 【模板】网络最大流
#include<bits/stdc++.h>
using namespace std;
const int MAXN = 205;
const int MAXM = 5e5 + 10;
#define int long long
const int INF = INT_MAX;
int head[MAXN], ver[MAXM << 1], nxt[MAXM << 1], edge[MAXM << 1], tot = 1;
inline void add(const int &x, const int &y, const int &z)
{
ver[++tot] = y;
edge[tot] = z;
nxt[tot] = head[x];
head[x] = tot;
}
int n, m, s, t, maxflow;
int v[MAXN], incf[MAXN], pre[MAXN];
bool bfs()
{
memset(v, 0, sizeof(v));
queue<int> q;
q.push(s);
v[s] = 1;
incf[s] = INF;//增广路上边的最小容量
while(q.size())
{
int x = q.front();
q.pop();
for(int i = head[x]; i; i = nxt[i])
{
if(edge[i])
{
int y = ver[i];
if(v[y])
continue;
incf[y] = min(incf[x], edge[i]);//更新最小容量
pre[y] = i;//记录前驱，用于更新
q.push(y);
v[y] = 1;
if(y == t)
return true;
}
}
}
return false;
}
void update()
/*更新增广路上边和反向边的容量*/
{
int x = t;
//利用前驱遍历增广路
while(x != s)
{
int i = pre[x];
edge[i] -= incf[t];//正向边-e
edge[i ^ 1] += incf[t];//反向边+e
x = ver[i ^ 1];//利用了成对存储的技巧
}
maxflow += incf[t];
}
signed main()
{
cin >> n >> m;
cin >> s >> t;
for(int i = 1; i <= m; ++i)
{
int x, y, z;
cin >> x >> y >> z;
add(x, y, z);
add(y, x, 0);
}
while(bfs())
update();
cout << maxflow << endl;
}
Dinic算法
残量网络：在任意时刻，网络中所有节点以及剩余容量大于0的边构成的子图被称为残量网络，Edmonds-Karp每一次bfs遍历了整个残量网络，但是只找一个增广路，不优。
分层图：\(d[y]=d[x]+1\)的边\((x,y)\)构成的子图就是一张分层图
Dinic算法过程如下：
1、bfs残量网络，构造分层图
2、dfs分层图，寻找增广路并更新剩余容量。优点在于dfs的时候可以同时寻找多条增广路，回溯时可以更新剩余容量。（dfs的时候有一些剪枝）
算法复杂度\(O(n^2m)\)，实际处理\(10^4\)~\(10^5\)的数据，并且在求解二分图最大匹配的时候复杂度为\(O(m\sqrt{n})\)
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int MAXN = 205;
const int MAXM = 5e3 + 10;
int head[MAXN], nxt[MAXM << 1], ver[MAXM << 1], edge[MAXM << 1], tot = 1;
int d[MAXN];
int n, m, s, t, maxflow;
inline void add(const int &x, const int &y, const int &z)
{
ver[++tot] = y;
edge[tot] = z;
nxt[tot] = head[x];
head[x] = tot;
}
bool bfs()
/*bfs构造分层图*/
{
queue<int> q;
memset(d, 0, sizeof(d));
q.push(s);
d[s] = 1;
while(q.size())
{
int x = q.front();
q.pop();
for(int i = head[x]; i; i = nxt[i])
{
int y = ver[i];
if(edge[i] && !d[y])
{
q.push(y);
d[y] = d[x] + 1;
if(y == t)
return true;
}
}
}
return false;
}
int dinic(int x, int flow)
/*dfs寻找多条增广路*/
{
if(x == t)
return flow;
int rest = flow, k;
for(int i = head[x]; i && rest; i = nxt[i])
{
int y = ver[i];
if(edge[i] && d[y] == d[x] + 1)
{
k = dinic(y, min(rest, edge[i]));
if(!k)//后续没有增广路，直接从分层图中去掉该节点，剪枝
d[ver[i]] = 0;
edge[i] -= k;
edge[i ^ 1] += k;
rest -= k;
}
}
return flow - rest;
}
signed main()
{
cin >> n >> m >> s >> t;
for(int i = 1; i <= m; ++i)
{
int x, y, z;
cin >> x >> y >> z;
add(x, y, z);
add(y, x, 0);
}
int flow = 0;
while(bfs())
while(flow = dinic(s, LONG_LONG_MAX))
maxflow += flow;
cout << maxflow << endl;
}
其他例题：
P2740 [USACO4.2]草地排水Drainage Ditches
还有一些其它算法等待学习：
Ford-Fulkerson（FF）：以为是很高级的其实是不分层图的Dinic（或者dfs的EK）
ISAP(Improved Shortest Augmenting Path，更优最短增广路径算法)：优化了求分层图的过程
HLPP算法：不依赖增广路，是一种预流推进算法
