标签：可行 入门 limits 增广 int sum 网络 入土 leqslant
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
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。