前言

EK算法是求网络最大流的最基础的算法,也是比较好理解的一种算法,利用它可以解决绝大多数最大流问题。

但是受到时间复杂度的限制,这种算法常常有TLE的风险

思想

还记得我们在介绍最大流的时候提到的求解思路么?

对一张网络流图,每次找出它的最小的残量(能增广的量),对其进行增广。

没错,EK算法就是利用这种思想来解决问题的

实现

EK算法在实现时,需要对整张图遍历一边。

那我们如何进行遍历呢?BFS还是DFS?

因为DFS的搜索顺序的原因,所以某些毒瘤出题人会构造数据卡你,具体怎么卡应该比较简单,不过为了防止大家成为这种人我就不说啦(#^.^#)

所以我们选用BFS

在对图进行遍历的时候,记录下能进行增广的最大值,同时记录下这个最大值经过了哪些边。

我们遍历完之后对这条增广路上的边进行增广就好啦

代码

题目在这儿

代码里面我对一些重点的地方加了一些注释,如果我没写明白的话欢迎在下方评论:blush:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
using namespace std;
const int MAXN=*1e6+;
const int INF=1e8+;
inline char nc()
{
static char buf[MAXN],*p1=buf,*p2=buf;
return p1==p2&&(p2=(p1=buf)+fread(buf,,MAXN,stdin),p1==p2)?EOF:*p1++;
}
inline int read()
{
char c=nc();int x=,f=;
while(c<''||c>''){if(c=='-')f=-;c=nc();}
while(c>=''&&c<=''){x=x*+c-'';c=nc();}
return x*f;
}
struct node
{
int u,v,flow,nxt;
}edge[MAXN];
int head[MAXN];
int num=;//注意这里num必须从0开始
inline void add_edge(int x,int y,int z)
{
edge[num].u=x;
edge[num].v=y;
edge[num].flow=z;
edge[num].nxt=head[x];
head[x]=num++;
}
inline void AddEdge(int x,int y,int z)
{
add_edge(x,y,z);
add_edge(y,x,);//注意这里别忘了加反向边
}
int N,M,S,T;
int path[MAXN];//经过的路径
int A[MAXN];//S到该节点的最小流量
inline int EK()
{
int ans=;//最大流
while(true)//不停的找增广路
{
memset(A,,sizeof(A));
queue<int>q;//懒得手写队列了。。。
q.push(S);
A[S]=INF;
while(q.size()!=)
{
int p=q.front();q.pop();
for(int i=head[p];i!=-;i=edge[i].nxt)
{
if(!A[edge[i].v]&&edge[i].flow)
{
path[ edge[i].v ]=i;//记录下经过的路径,方便后期增广
A[edge[i].v]=min(A[p],edge[i].flow);//记录下最小流量
q.push(edge[i].v);
}
}
if(A[T]) break;//一个小优化
}
if(!A[T]) break;//没有可以增广的路径,直接退出
for(int i=T;i!=S;i=edge[path[i]].u)//倒着回去增广
{
edge[path[i]].flow-=A[T];
edge[path[i]^].flow+=A[T];//利用异或运算符寻找反向边,0^1=1 1^1=0
}
ans+=A[T];
}
return ans;
}
int main()
{
#ifdef WIN32
freopen("a.in","r",stdin);
#else
#endif
memset(head,-,sizeof(head));
N=read(),M=read(),S=read(),T=read();
for(int i=;i<=M;i++)
{
int x=read(),y=read(),z=read();
AddEdge(x,y,z);
}
printf("%d", EK() );
return ;
}

性能分析

通过上图不难看出,这种算法的性能还算是不错,

不过你可以到这里提交一下就知道这种算法究竟有多快(man)了

可以证明,这种算法的时间复杂度为$O(n*m^2)$

大体证一下:

我们最坏情况下每次只增广一条边,则需要增广$m-1$次。

在BFS的时候,由于反向弧的存在,最坏情况为$n*m$

总的时间复杂度为$O(n*m^2)$

后记

EK算法到这里就结束了。

不过loj那道题怎么才能过掉呢?

这就要用到我们接下来要讲的其他算法

最新文章

  1. sql 保留两位小数+四舍五入
  2. 《OOC》笔记(0)——为何要看这本书
  3. [转]Mysql海量数据存储和解决方案之一—分布式DB方案
  4. IOS 网络浅析-(五 xml解析)
  5. 超级链接a+ confirm用法
  6. crm SSRS 报表 导出格式控制
  7. SCSS(SASS、CSS)学习
  8. SharePoint2013切换帐户登录菜单
  9. 获取windows所有用户名
  10. Android热修复框架汇总整理(Hotfix)
  11. 【NOIP 2017】逛公园
  12. Apache 、Tomcat、Nginx的区别
  13. 通过DFS求解有向图(邻接表存储)中所有简单回路
  14. HAOI 2018 染色(容斥+NTT)
  15. SQL注入之Sqli-labs系列第三十二关(基于宽字符逃逸注入)
  16. vue 父组件中的数据如何传递给子组件
  17. 日记整理----&gt;2016-11-26
  18. 为什么JavaScript声明变量的时候鼓励加var关键字
  19. CentOS 7 下编译安装lnmp之MySQL篇详解
  20. 给WebAPI的REST接口服务添加测试页面(一)

热门文章

  1. Linux jdk 环境变量配置
  2. 查看Python安装路径
  3. 【设计经验】5、Verilog对数据进行四舍五入(round)与饱和(saturation)截位
  4. 源码级调试的XNU内核
  5. [Swift]LeetCode561. 数组拆分 I | Array Partition I
  6. [Swift]LeetCode868. 二进制间距 | Binary Gap
  7. 性能调优之Transformation
  8. 英语笔记3(git)
  9. Android-线程池下载多个图片并保存,如果本地有该图,则不下载,直接展示到view
  10. Volatile的那些事