网络流——从入门到入土
作者：互联网
1. 网络流的基本概念
注： \(G\) 为流网络， \(f\) 为可行流， \(|f|\) 为可行流的大小。
1. 流网络
一个有向图 \(G=(V,E)\) ，每一条边都有流量限制 \(C(u,v)\) ，源点为 \(s\) ，汇点为 \(t\) 。
2. 可行流
设一个可行流为 \(f\) ，它需要满足两个限制：
1.容量限制：
\(\forall (u,v)\in E,0\leqslant f(u,v)\leqslant C(u,v)\)
对于每一条边，它的流量一定是大于 \(0\) 小于流量限制的。
2.流量守恒：
\(\forall x\in V|\{s,t\},\sum\limits_{(u,x)\in E}f(u,x)=\sum\limits_{(x,v)\in E}f(x,v)\)
对于每一个点（除了源点和汇点）,它收到的流量等于输出的流量。
3. 可行流的大小
\(|f|=\sum\limits_{(s,v)\in E}f(s,v)-\sum\limits_{(v,s)\in E}f(v,s)\)
可行流的大小即为源点输出的流量减去收到的流量（一般没有连向源点的边）。
4. 最大流
最大流，全称为最大可行流。
即为流网络中大小最大的可行流。
5. 残留网络
对于每一个可行流 \(f\) ，都有一个残留网络 \(G\) ，且可行流与残留网络是一一对应的。
一般记为 \(G_f\)。
1.性质
\(V_f=V\)
残留网络包含原图中的所有点。
\(E_f=E+E'\)
残留网络包含原图中的所有边以及反向边。
设 \(C'(u,v)\) 为残留网络中每条边的容量。
\(C'(u,v)=\begin{cases}C(u,v)-f(u,v)&(u,v)\in E\\f(v,u)&(v,u)\in E\end{cases}\)
若当前边为正向边，容量即为原容量减去现在的流量，否则即为现在的流量。
设 \(G_f\) 的可行流为 \(f'\) 。
\(f+f'\) 也是 \(G\) 的一个可行流。
2. 流网络的相加
\(\forall (u,v) \in E,f(u,v)\gets\begin{cases}f(u,v)+f'(u,v)&(u,v)\in E'\\f(u,v)-f'(v,u)&(v,u)\in E\end{cases}\)
对于每一条边，若另一个流网络中存在与它相同方向的边，则将两流量相加，否则相减。
若 \(f+f'\) 是 \(G\) 的一个可行流，那么它需要满足可行流的两个条件。
1.容量限制
若对于 \((u,v)\in E\) ，有 \((u,v)\in E'\) 。
\(\Rightarrow 0\leqslant f'(u,v)\leqslant C'(u,v)=C(u,v)-f(u,v)\)
\(\Rightarrow 0\leqslant f'(u,v)\leqslant C(u,v)-f(u,v)\)
\(\Rightarrow 0\leqslant\color{red}{f'(u,v)+f(u,v)\leqslant C(u,v)}\)
若对于 \((u,v)\in E\) ，有 \((v,u)\in E'\) 。
\(\Rightarrow 0 \leqslant f'(u,v)\leqslant C'(u,v)=f(v,u)\leqslant C(v,u)\)
\(\Rightarrow 0 \leqslant\color{red}{f(v,u)-f'(u,v) \leqslant C(u,v)}\)
至此，可证明 \(f+f'\) 满足容量限制。
2.流量守恒
对于 \(f\) 中的所有点，都满足流量守恒。
\(f'\) 同样满足，而相加不改变守恒。
易得 \(f+f'\) 满足流量守恒。
可得 \(|f+f'|=|f|+|f'|\)
所以残留网络中的可行流是可以加到流网络的可行流中的。
可以推出如果残留网络没有可行流，流网络一定是最大流。
6. 增广路
在残留网络里面，从源点出发，沿着容量大于 \(0\) 的边走，如果可以走到汇点，那么这条边是增广路。
增广路是无环无交点的简单路径。
对于一个可行流 \(f\) ，若残留网络 \(G_f\) 中没有增广路，那么 \(f\) 是最大流。
7. 流网络的割
一般的，设流网络的两个点集为 \(X\) 和 \(Y\)。
可得 \(f(X,Y)=\sum\limits_{u\in X}\sum\limits_{v\in Y}f(u,v)-\sum\limits_{u\in Y}\sum\limits_{v\in X}f(u,v)\)
性质一： \(f(X,Y)=-f(Y,X)\)
性质二： \(f(X,X)=0\)
性质三： \(f(Z,X\bigcup Y)=f(Z,X)+f(Z,Y)\{X\bigcup Y=\varnothing\}\)
对于流网络 \(G=(V,E)\) ，将 \(V\) 分为 \(S\) 和 \(T\) 。
满足 \(S\bigcup T=V\) ， \(S\bigcap T=\varnothing\) ， \(s\in S\) ， \(t\in T\) 。
1. 割的容量
\(C(S,T)=\sum\limits_{u\in S}\sum\limits_{v\in T}C(u,v)\)
割的容量为从 \(S\) 到 \(T\) 的边的容量之和。
最小割指的是容量最小的割。
2. 割的流量
\(f(S,T)=\sum\limits_{u\in S}\sum\limits_{v\in T}f(u,v)-\sum\limits_{u\in T}\sum\limits_{v\in S}f(u,v)\)
割的流量为从 \(S\) 到 \(T\) 的边的流量之和减去从 \(T\) 到 \(S\) 的边的流量之和。
3. 割的性质
\(\forall \left[S,T\right],\forall f,f(S,T)\leqslant C(S,T)\)
对于每一个割和每一个可行流，割的流量小于等于割的容量。
\(f(S,T)=\sum\limits_{u\in S}\sum\limits_{v\in T}f(u,v)-\sum\limits_{u\in T}\sum\limits_{v\in S}f(u,v)\)
\(\Rightarrow f(S,T)\leqslant\sum\limits_{u\in S}\sum\limits_{v\in T}f(u,v)\)
\(\because \sum\limits_{u\in S}\sum\limits_{v\in T}f(u,v)\leqslant \sum\limits_{u\in S}\sum\limits_{v\in T}C(u,v)=C(S,T)\)
\(\Rightarrow \color{red}{f(S,T)\leqslant C(S,T)}\)
\(\forall [S,T],\forall f,f(S,T)=|f|\)
对于每一个割和每一个可行流，割的容量等于可行流的大小。
\(f(S,V)=f(S,S)+f(S,T)\) （性质一）
\(\Rightarrow f(S,T)=f(S,V)-f(S,S)\)
\(\Rightarrow f(S,T)=f(S,V)\)
\(\Rightarrow f(S,T)=f(\{s\},V)+f(S-\{s\},V)\)
设 \(S'=S-\{s\}\)
\(\because f(S',V)=\sum\limits_{u\in S'}\sum\limits_{v\in V}f(u,v)-\sum\limits_{u\in S'}\sum\limits_{v\in V}f(v,u)\)
\(\Rightarrow f(S',V)=\sum\limits_{u\in S'}\big(\sum\limits_{v\in V}f(u,v)-\sum\limits_{v\in V}f(v,u)\big)=0\)
\(\therefore f(S,T)=f(s,V)=|f|\)
\(\Rightarrow \color{red}{f(S,T)=|f|}\)
综上可以推出：\(|f|\leqslant C(S,T)\)
即为最大流\(\leqslant\)最小割
8. 最大流最小割定理
对于流网络 \(G=(V,E)\) ，同时满足下面三个条件。
1. \(f\) 是最大流
2. \(G_f\) 中不存在增广路
3. \(\exists \left[S,T\right],|f|=C(S,T)\)
\(1\Rightarrow2\)
设 \(f\) 为当前可行流，若存在增广路 \(f'\) ，那么 \(|f+f'|\geqslant|f|\) 。
\(2\Rightarrow3\)
在 \(G_f\) 中从 \(s\) 出发沿着容量大于 \(0\) 的边走到的所有的点均在 \(S\) 中。
\(T=V-S\)
\(\forall (x,y)\{x\in S,y\in T\},f(x,y)=C(x,y)\)
\(\forall (a,b)\{a\in T,b\in S\},f(a,b)=0\)
\(\because |f|=f(S,T)\)
\(\Rightarrow |f|=\sum\limits_{u\in S}\sum\limits_{v\in T}f(u,v)-\sum\limits_{u\in S}\sum\limits_{v\in T}f(v,u)\)
\(\Rightarrow |f|=\sum\limits_{u\in S}\sum\limits_{v\in T}C(u,v)=C(S,T)\)
\(3\Rightarrow1\)
\(|f|=C(S,T)\geqslant|f_{max}|\)
又 \(\because |f|=|f_{max}|\)
\(\therefore |f|=C(S,T)\)
最大流等于最小割
2. 网络流的模板
1. FF
因为最大流中没有增广路，所以可以通过不断的找增广路来找到原图的最大流。
这就是 FF 思想，也是一堆最大流算法的根源。
2. EK
通过暴力找增广路，然后加入残留网络，这是 EK 的思想。
大概分为以下几步：
- 通过 BFS 找到一条增广路 \(f'\)
- 更新残留网络，若对于一条边 \((u,v)\) 流过了 \(k\) 的流量，那么 \(\begin{cases}C(u,v)=C(u,v)-k\\C(v,u)=C(v,u)+k\end{cases}\)
- 需要减的流量为找到增广路上最小的容量
肯定用邻接表存图，所以有一个小 trick ： \(i\) 的反向边为 \(i \oplus 1\)
时间复杂度不优，为 \(O(nm^2)\)
但是跑不满，\(10^3\) 到 \(10^4\) 可跑。
最大流一般不用，但是费用流要用。
代码实现：
#include<bits/stdc++.h>
using namespace std;
const int MAXN=2e5+5;
struct node
{
int to,nxt,flow;
}e[MAXN];
int head[MAXN],cnt=1;//因为要异或得反向边，cnt需从1开始
int n,m,s,t;
inline void add(int x,int y,int f)
{
e[++cnt].to=y;
e[cnt].flow=f;
e[cnt].nxt=head[x];
head[x]=cnt;
}
bitset<MAXN>vis;
int pre[MAXN],dis[MAXN];//pre记录当前点是从哪条边过来的，dis是当前点之前最小的容量
inline bool bfs()//bfs找一条增广路
{
vis=0;
vis[s]=1;
dis[s]=0x7f7f7f7f;
queue<int>q;
q.push(s);
while(!q.empty())
{
int x=q.front();
q.pop();
for(register int i=head[x];i;i=e[i].nxt)
{
int y=e[i].to,f=e[i].flow;
if(!vis[y]&&f)//若没有经过且容量大于0，则可以成为增广路的一部分
{
pre[y]=i;//直接记录边的编号
dis[y]=min(dis[x],f);
vis[y]=1;
if(y==t)return true;//现在到了汇点，直接找到了
q.push(y);
}
}
}
return false;
}
inline void EK()
{
int ans=0;
while(bfs())
{
ans+=dis[t];
for(register int i=t;i!=s;i=e[pre[i]^1].to)//不断遍历直到访问到源点
{
e[pre[i]].flow-=dis[t];//流过的边容量要减
e[pre[i]^1].flow+=dis[t];//小trick应用处
}
}
printf("%d",ans);
}
int main()
{
scanf("%d%d%d%d",&n,&m,&s,&t);
for(register int i=1;i<=m;i++)
{
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
add(x,y,z);
add(y,x,0);//反向边最初容量为0
}
EK();
return 0;
}
3. dinic
思想类似于EK，但是一次可以找到多条增广路 。
通过暴搜来找到当前残留网络中的所有增广路。
但是需要注意的是，如果残留网络中有环，这个算法就寄了。
所以需要引进一个叫做分层图的概念，即只能从层数低的走向层数高的。
最开始BFS一次，分层图的层数即为到源点的最短距离。
接下来DFS一次将所有增广路找出且增广。
有一个优化为当前弧优化。
即记录当前点有多少条出边是满的，可以有效的降低时间复杂度。
代码实现：
#include<bits/stdc++.h>
#define register signed
using namespace std;
const int MAXN=2e5+5;
const int INF=0x7f7f7f7f;
struct node
{
int to,nxt,flow;
}e[MAXN];
int head[MAXN],cnt=1;
inline void add(int x,int y,int f)
{
e[++cnt].to=y;
e[cnt].flow=f;
e[cnt].nxt=head[x];
head[x]=cnt;
}
int n,m,s,t;
int dis[MAXN],cur[MAXN];//dis是分层图层数，cur是当前弧优化
inline bool bfs()//bfs判断是否有增广路以及建立分层图
{
queue<int>q;
memset(dis,-1,sizeof(dis));
dis[s]=0;
cur[s]=head[s];
q.push(s);
while(!q.empty())
{
int x=q.front();
q.pop();
for(register int i=head[x];i;i=e[i].nxt)
{
int y=e[i].to,f=e[i].flow;
if(dis[y]==-1&&f)//层数为-1代表没有走过
{
dis[y]=dis[x]+1;
cur[y]=head[y];//初始化cur[y]为y连出的第一条边
if(y==t)return true;
q.push(y);
}
}
}
return false;
}
inline int dfs(int x,int lim)//dfs找增广路，x是当前到的节点，lim是当前点的流量限制
{
if(x==t)return lim;
int f=0;//当前点流出的流量
for(register int i=cur[x];i&&f<lim;i=e[i].nxt)//从第一条没有满的边出发，且保证流出的流量不超过限制
{
int y=e[i].to;
cur[x]=i;//如果到了第i条边，那么前面的所有边一定都走完了
if(dis[y]==dis[x]+1&&e[i].flow)//需要保证分层图的限制才能继续
{
int t=dfs(y,min(e[i].flow,lim-f));//前往的点的限制即为这条边的容量和剩余流量的中较小的一个
if(!t)dis[y]=-1;//返回流量为0，说明不能到汇点，标记以后都不走
e[i].flow-=t;
e[i^1].flow+=t;
f+=t;
}
}
return f;
}
inline int dinic()
{
int ans=0,f;
while(bfs())while(f=dfs(s,INF))ans+=f;//只要当前残留网络中有增广路（bfs），就找出并累加（dfs）
return ans;
}
int main()
{
scanf("%d%d%d%d",&n,&m,&s,&t);
for(register int i=1;i<=m;i++)
{
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
add(x,y,z);
add(y,x,0);
}
printf("%d",dinic());
return 0;
}
时间复杂度较优，为 \(O(n^2m)\)
同样跑不满，\(10^4\) 到 \(10^5\) 可跑。
3.最大流的分析方法
对于可行解中的任何一个，可以转化为一个可行流，反之亦可，所以最大可行解等于最大流，求最大流即可。
标签：可行,入门,limits,增广,int,sum,网络,入土,leqslant 来源： https://www.cnblogs.com/yzh-error502/p/15915283.html