版权声明：转载请注明出处哦。 https://blog.csdn.net/Dch19990825/article/details/88756689
(网络流，最小割自我总结)
网络流我习惯采用EK算法
1.网络流
思想:
每次从残留网络找出一条增广路，并且沿着这条路增广即可，直至没有增广路。
关于网络流的用处：
网络流就像水流一样，求最大的水流速率，很多问题可以转化为网络流模型来解决
- 二分图匹配( 最少边覆盖)
网络流的做题经验：
求最大消耗量：将产生值的连接到源点，消耗值的连接到汇点
顶点上有最大容量限制： 插点即可
边上有最小容量限制：（先放一放）假设u到v的最小容量限制为b(e), 那么新增S‘，T’ 让 u到T‘ 流量为b(e),S’到v的流量为b(e) 然后令u到v的容量为c(e)-b(e) 。不过要在S与s，T与t连接之前，先检查S到T的最大容量是否为Sum(e)(让 v到s容量为b(e),)
代码：
总是沿着最短的增广路进行增广
时间复杂度约为O(V*E^2) 1ms有800个顶点有不稳了。上界为O(F*M)，其中 f 是最大流，
#include<queue>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<cstdio>
#define mset(a,b) memset(a,b,sizeof(a))
using namespace std;
const int maxn=120;
const int inf=0x3f3f3f3f;
struct edge{
int cap,rev,to;//储存 容量、邻接点、反向边
edge(){};
edge(int to,int cap,int rev){this->to=to,this->cap=cap,this->rev=rev;}
};
class EK{
public:
vector<edge> adja[maxn];
int prevv[maxn],top;
int preve[maxn];
void init(int n)
{
for(int i=0;i<n;++i) adja[i].clear();
top=n;
}
void bfs(int s,int t)
{
memset(prevv,-1,sizeof(prevv));
queue<int> mmp;
mmp.push(s);
prevv[s]=s;
while(!mmp.empty()){
int u=mmp.front();
mmp.pop();
for(int i=0;i<adja[u].size();++i){
edge& e=adja[u][i];
if(prevv[e.to]==-1&&e.cap>0)
{
prevv[e.to]=u;
preve[e.to]=i;
mmp.push(e.to);
}
}
}
}
void addEdge(int u,int v,int f)
{
adja[u].push_back(edge(v,f,adja[v].size()));
adja[v].push_back(edge(u,0,adja[u].size()-1));
}
int maxFlow(int s,int t)
{
int flow=0;
for(;;)
{
bfs(s,t);
if(prevv[t]==-1)
return flow;
else
{
int minn=inf;
for(int last=t;prevv[last]!=last;last=prevv[last]){
minn=min(minn,adja[prevv[last]][preve[last]].cap);
}
flow+=minn;
for(int last=t;prevv[last]!=last;last=prevv[last]){
edge& e=adja[prevv[last]][preve[last]];
e.cap-=minn;
adja[last][e.rev].cap+=minn;
}
}
}
}
};
EK kit;
int main()
{
}
我bing神的模板贼快 ISAP+BSF+栈优化
const int MAXN=100010;//点数的最大值
const int MAXM=400010;//边数的最大值
const int INF=0x3f3f3f3f;
const int inf=0x3f3f3f3f;
struct Edge
{
int to,next,cap,flow;
} edge[MAXM];
class ISAP
{
//输入参数:起点、终点、点的总数
//点的编号没有影响，只输入点的总数
public:
int tol;
int head[MAXN];
int gap[MAXN],dep[MAXN],cur[MAXN];
void init()
{
tol=0;
mset(head,-1);
}
void addEdge(int u,int v,int w,int rw=0)
{
edge[tol].to=v,edge[tol].cap=w,edge[tol].next=head[u];
edge[tol].flow=0,head[u]=tol++;
edge[tol].to=u,edge[tol].cap=rw,edge[tol].next=head[v];
edge[tol].flow=0,head[v]=tol++;
}
int Q[MAXN];
void BFS(int start,int end)
{
mset(dep,-1),mset(gap,0);
gap[0]=1;
int front=0,rear=0;
dep[end]=0;
Q[rear++]=end;
while(front!=rear)
{
int u=Q[front++];
for(int i=head[u]; i!=-1; i=edge[i].next)
{
int v=edge[i].to;
if(dep[v]!=-1) continue;
Q[rear++]=v;
dep[v]=dep[u]+1;
gap[dep[v]]++;
}
}
}
int S[MAXN];
int sap(int start,int end,int N)//只输入源点和汇点的编号 和顶点个数
{
BFS(start,end);
memcpy(cur,head,sizeof(head));
int top=0,u=start,ans=0;
while(dep[start]<N)
{
if(u==end)
{
int Min=INF;
int inser;
for(int i=0;i<top;i++)
{
if(Min>edge[S[i]].cap-edge[S[i]].flow){
Min=edge[S[i]].cap-edge[S[i]].flow;
inser=i;
}
}
for(int i=0;i<top;++i){
edge[S[i]].flow+=Min;
edge[S[i]^1].flow-=Min;
}
ans+=Min;
top=inser;
u=edge[S[top]^1].to;
continue;
}
bool flag=false;
int v;
for(int i=cur[u]; i!=-1; i=edge[i].next)
{
v= edge[i].to;
if(edge[i].cap-edge[i].flow&&dep[v]+1==dep[u])
{
flag=true;
cur[u]=i;
break;
}
}
if(flag)
{
S[top++]=cur[u];
u=v;
continue;
}
int Min= N;
for(int i=head[u]; i!=-1; i=edge[i].next)
{
if(edge[i].cap-edge[i].flow&&dep[edge[i].to]<Min)
{
Min=dep[edge[i].to];
cur[u]=i;
}
}
gap[dep[u]]--;
if(!gap[dep[u]]) return ans;
dep[u]=Min+1;
gap[dep[u]]++;
if(u!=start) u=edge[S[--top]^1].to;
}
return ans;
}
};
2.最小割：
该引用来自https://zhuanlan.zhihu.com/p/43830785
0x03最小割最大流定理
G的一个割把点集V分为两部分,其中源点S属于其中一部分,汇点T属于另外一部分.割是G的边集E的一个子集,每条边的两个端点分别属于不同的点集.割的容量定义为割的每条边的容量和,最小割就是容量最小的一个割.
例子:
黄色的边就是一个割
介绍一下网络流中最重要的定理之一------最小割最大流定理:
如果f是G中一个流,则以下条件是等价的:
1.f是G的一个最大流
2.残留网络
不包含增广路
3.存在一个割,|f|等于其容量
那么如何借此求出最小割呢?
我们看可以先求出最大流,以S为起点在残留网络上DFS,搜索到的点就是包含S的一部分,剩余的则是另一部分,而最小割即是连接两部分的所有边.