这是网络流最基础的部分——求出源点到汇点的最大流（Max-Flow）。
最大流的算法有比较多，本次介绍的是其中复杂度较高，但是比较好写的EK算法。（不涉及分层，纯粹靠BFS找汇点及回溯找最小流量得到最终的答案）

EK算法，全名Edmonds-Karp算法(最短路径增广算法)。

首先简单介绍一下网络流的基本术语：
源点：起点。所有流量皆从此点流出。只出不进。
汇点：终点。所有流量最后汇集于此。只进不出。
流量上限：有向边(u,v)（及弧）允许通过的最大流量。
增广路：一条合法的从源点流向汇点的路径。
计算最大流就是不停寻找增广路找到最大值的过程。

合法的网络流具有以下性质：
1.f(i,j) <= c(i,j);//任意有向边的流量一定小于等于该边的流量限制
2.f(i,j) = -f(j,i);//从i流向j的流量与j流向i的流量互为相反数（反向边）
3.out(i) = in(i);//除源点、汇点外，任意一点i流入的流量与流出的相等（只是路过）

（截自洛谷）

EK算法思路：
1.通过BFS拓展合法节点（每个节点在本次BFS中仅遍历一次），找到汇点，并记录每个节点的前面节点（pre）（若找不到增广路，算法结束）
2.通过BFS的记录，从汇点回溯回源点，记录下每条弧流量的**最小值**minn, ans += minn（否则就会超出某条边的限制流量）
3.将所有经过的边的流量减去minn，反向边加上minn
4.重复上述步骤，直到找不到增广路，算法结束。

朴素版EK：
最为简单的写法，通过邻接矩阵存储。
优点：代码简单，一目了然。
缺点：轻易爆内存，（N^2）的空间太大，N >10000基本就废了（MLE）。
源代码：

  1. #include <bits/stdc++.h>
  2. using namespace std;
  3. #define INF 0x3f3f3f
  4. #define maxn 10005
  6. int n, m, st, en, flow[maxn][maxn], pre[maxn];
  7. int q[maxn], curr_pos, st_pos, end_pos;
  8. bool wh[maxn];
  9. int max_flow;
  11. void Init()//初始化
  12. {
  13.     int i, a, b, c;
  14.     scanf("%d%d%d%d", &n, &m, &st, &en);
  15.     for(i = 0; i != m; ++i)
  16.     {
  17.         scanf("%d%d%d", &a, &b, &c);
  18.         flow[a][b] += c;
  19.     }
  20.     return ;
  21. }
  23. bool Bfs(int st, int en)//广搜找源点
  24. {
  25.     st_pos = -1, end_pos = 0;
  26.     memset(wh, 0, sizeof wh);
  27.     wh[st] = 1;
  28.     q[0] = st;
  29.     while(st_pos != end_pos)
  30.     {
  31.         curr_pos = q[++st_pos];
  32.         for(int i = 1; i != n+1; ++i)
  33.         {
  34.             if(!wh[i] && flow[curr_pos][i] > 0)
  35.             {
  36.                 wh[i] = 1;
  37.                 pre[i] = curr_pos;
  38.                 if(i == en)
  39.                 {
  40.                     return true;
  41.                 }
  42.                 q[++end_pos] = i;
  43.             }
  44.         }
  45.     }
  46.     return false;
  47. } 
  49. int EK(int start_pos, int end_pos)
  50. {
  51.     int i, minn;
  52.     while(Bfs(start_pos, end_pos))//回溯
  53.     {
  54.         minn = INF;
  56.         for(i = end_pos; i != start_pos; i = pre[i])
  57.         {
  58.             minn = min(minn, flow[pre[i]][i]);
  59.         } 
  61.         for(i = end_pos; i != start_pos; i = pre[i])
  62.         {
  63.             flow[pre[i]][i] -= minn;
  64.             flow[i][pre[i]] += minn;//反向弧加上该值（具体原因下文详解）
  65.         }
  66.         max_flow += minn;
  67.     }
  68.     return max_flow;
  69. }
  71. int main()
  72. {
  73.     //freopen("test.in", "r", stdin);
  74.     //freopen("test.out", "w", stdout);
  76.     Init();
  78.     printf("%d", EK(st, en));
  80.     //fclose(stdin);
  81.     //fclose(stdout);
  82. }

经过洛谷测评（P3376 【模板】网络最大流），50分，MLE五个点。

关于反向边加上最小流值的原因：
如果存在a->b有流，那么如果某一点c->b有流，则流量实际上可以再从b流到a，可以理解为把原本a->b的流量怼了回去。
BFS遍历得到的剩下部分的增广路的流量实际上是原本a->b的流，而原本a->b之后流向汇点的增广路的部分流量变为由c->b的流量。
增广路依旧合法。

这证明了邻接矩阵是不可行的，于是我们想到了麻烦一点但是省空间的存储方法——边表。至少从m*m优化到n*m，实则通常n*(m/10)便足够。

定义一个结构体

  1. struct qi{
  2.     int st, en, num;//弧的始点，终点，权值
  3. }flow[maxm];

相对应的广搜也要稍作调整，注意一下pre的存储方法：
pre[i]=k，i是点，k是弧的编号。

  1. bool Bfs(int st, int en)
  2. {
  3.     st_pos = -1, end_pos = 0;
  4.     memset(wh, 0, sizeof wh);
  5.     wh[st] = 1;
  6.     q[0] = st;
  7.     while(st_pos != end_pos)
  8.     {
  9.         curr_pos = q[++st_pos];
  10.         for(int i = 0; i < 2*m; ++i)
  11.         {
  12.             if(flow[i].st == curr_pos && flow[i].num > 0 && !wh[flow[i].en])
  13.             {
  14.                 ne = flow[i].en;
  15.                 wh[ne] = 1;
  16.                 pre[ne] = i;
  17.                 if(ne == en)
  18.                 {
  19.                     return true;
  20.                 }
  21.                 q[++end_pos] = flow[i].en;
  22.             }
  23.         }
  24.     }
  25.     return false;
  26. }

所以Tracback的遍历循环也要改变。

  1. for(i = end_pos; i != st; i = flow[pre[i]].st)//注意一下i如何取下一个的
  2. {
  3.     minn = min(minn, flow[pre[i]].num);
  4. }

事实证明：MLE的问题完美解决，测试结果：94ms , 18785kb，TLE三个点。

那么还需要优化一下时间。
注意BFS拓展时的循环：i：=0->2*m//m是弧的个数（因为有反向边，故是2*m）
由于题目范围是m <= 100000，每次最大循环达到2e5，太浪费了。
于是我们在边表再做一点手脚：开二维数组对每个始点所有的弧分别记录。
x[i][m]指以i为始点的第m条弧（再开一个num[i]记录每个始点弧的个数）。
那么代码就更加繁琐了。

首先是读入优化：

  1. int read()
  2. {
  3.     input = 0;
  4.     a = getchar();
  5.     while(a < '0' || a > '9')
  6.         a = getchar();
  7.     while(a >= '0' && a <= '9')
  8.     {
  9.         input = input*10+a-'0';
  10.         a = getchar();
  11.     }
  12.     return input;
  13. }

然后是初始化：

  1. void Init()
  2. {
  3.     int i, a, b, c;
  4.     memset(num, -1, sizeof num);
  5.     n = read(), m = read(), st = read(), en = read();
  6.     for(i = 0; i != m; ++i)
  7.     {
  8.         flow[i].st = read();
  9.         flow[i].en = read();
  10.         flow[i].num = read();
  11.         re[flow[i].st][++num[flow[i].st]] = i;
  12.         re[flow[i].en][++num[flow[i].en]] = i+m;//初始化时将第i条弧的反向边编号为i+m
  13.     }
  14.     for(int i = m; i != 2*m; ++i)
  15.     {
  16.         flow[i].st = flow[i-m].en;
  17.         flow[i].en = flow[i-m].st;
  18.         flow[i].num = 0;
  19.     }
  20.     pre[st] = -1;
  21.     return ;
  22. }

BFS部分：

  1. bool Bfs(int st, int en)
  2. {
  3.     int i, j;
  4.     st_pos = -1, end_pos = 0;
  5.     memset(wh, 0, sizeof wh);
  6.     wh[st] = 1;
  7.     q[0] = st;
  8.     while(st_pos != end_pos)
  9.     {
  10.         curr_pos = q[++st_pos];
  11.         for(i = 0; i < num[curr_pos]+1; ++i)
  12.         {
  13.             j = re[curr_pos][i];//当前可拓展节点的候选节点，即当前节点的第i条弧的终点
  14.             if(flow[j].st == curr_pos && flow[j].num > 0 && !wh[flow[j].en])
  15.             {
  16.                 ne = flow[j].en;
  17.                 wh[ne] = 1;
  18.                 pre[ne] = j;
  19.                 if(ne == en)
  20.                 {
  21.                     return true;
  22.                 }
  23.                 q[++end_pos] = flow[j].en;
  24.             }
  25.         }
  26.     }
  28.     return false;
  29. }

Traceback只需改变反向边部分：

  1. flow[pre[i]+m].num += minn;

主函数部分不需要调整。

最终测评结果：392ms , 56988kb，AC。

通过上述过程，我们得知网络流的存储结构应该为边表而非邻接矩阵。当然，使用vector来存储弧也是可以的，这样会更大程度上节省空间，但会对时间造成一定影响，根据实际情况自行取舍。

最后附上完整代码：

  1. /*
  2. Max_flow- EK
  3. 2017/04/07
  4. While(BFS can find the end)
  5. for i,i->j:=st -> end:
  6. f[i][j] -= minn;f[j][i] += minn; ans += minn;//so we can delete at least one edge(the one which satisfies f[i][j] == minn)
  7. */
  8. #include <bits/stdc++.h>
  9. using namespace std;
  10. #define INF 0x3f3f3f
  11. #define maxm 200005
  12. #define maxn 10005
  14. struct qi{int st, en, num;}flow[maxm];
  15. int n, m, st, en, pre[maxn], re[maxn][maxn/10], num[maxn];
  16. int q[maxn], curr_pos, st_pos, end_pos, ne, max_flow;
  17. bool wh[maxn];
  18. int input;
  19. char a;
  21. int read()
  22. {
  23.     input = 0;
  24.     a = getchar();
  25.     while(a < '0' || a > '9')
  26.         a = getchar();
  27.     while(a >= '0' && a <= '9')
  28.     {
  29.         input = input*10+a-'0';
  30.         a = getchar();
  31.     }
  32.     return input;
  33. }
  35. void Init()
  36. {
  37.     int i, a, b, c;
  38.     memset(num, -1, sizeof num);
  40.     n = read(), m = read(), st = read(), en = read();
  41.     for(i = 0; i != m; ++i)
  42.     {
  43.         flow[i].st = read();
  44.         flow[i].en = read();
  45.         flow[i].num = read();
  46.         re[flow[i].st][++num[flow[i].st]] = i;
  47.         re[flow[i].en][++num[flow[i].en]] = i+m;
  48.     }
  49.     for(i = m; i != 2*m; ++i)
  50.     {
  51.         flow[i].st = flow[i-m].en;
  52.         flow[i].en = flow[i-m].st;
  53.     }
  54.     return ;
  55. }
  57. bool Bfs(int st, int en)
  58. {
  59.     int i, j;
  60.     st_pos = -1, end_pos = 0;
  61.     memset(wh, 0, sizeof wh);
  62.     wh[st] = 1;
  63.     q[0] = st;
  65.     while(st_pos != end_pos)
  66.     {
  67.         curr_pos = q[++st_pos];
  68.         for(i = 0; i < num[curr_pos]+1; ++i)
  69.         {
  70.             j = re[curr_pos][i];
  71.             if(flow[j].st == curr_pos && flow[j].num > 0 && !wh[flow[j].en])
  72.             {
  73.                 ne = flow[j].en;
  74.                 wh[ne] = 1;
  75.                 pre[ne] = j;
  76.                 q[++end_pos] = flow[j].en;
  77.                 if(ne == en)
  78.                     return true;
  79.             }
  80.         }
  81.     }
  83.     return false;
  84. } 
  86. int EK(int start_pos, int end_pos)
  87. {
  88.     int i, minn;
  89.     while(Bfs(start_pos, end_pos))
  90.     {
  91.         minn = INF;
  93.         for(i = end_pos; i != st; i = flow[pre[i]].st)
  94.         {
  95.             minn = min(minn, flow[pre[i]].num);
  96.         } 
  98.         for(i = end_pos; i != st; i = flow[pre[i]].st)
  99.         {
  100.             flow[pre[i]].num -= minn;
  101.             flow[pre[i]+m].num += minn;
  102.         } 
  104.         max_flow += minn;
  105.     }
  106.     return max_flow;
  107. }
  109. int main()
  110. {
  111.     //freopen("test.in", "r", stdin);
  112.     //freopen("test.out", "w", stdout);
  114.     Init();
  116.     printf("%d", EK(st, en));
  118.     //fclose(stdin);
  119.     //fclose(stdout);
  120. }

自此，EK算法的讲解便结束了。
箜瑟_qi 2017.04.07 2:32

2017.04.21略加修改：

  1. /*
  2. Max_flow- EK
  3. 2017/04/07
  4. */
  5. #include <bits/stdc++.h>
  6. using namespace std;
  7. #define INF 0x3f3f3f
  8. #define maxm 200005
  9. #define maxn 10005
  11. struct Edge{
  12.     int st, en, num;
  13.     Edge(){}
  14.     Edge(int s, int e, int n):
  15.         st(s), en(e), num(n){}
  16. }flow[maxm];
  18. int n, m, st, en, pre[maxn], re[maxn][maxn/10], num[maxn];
  19. int q[maxn], curr_pos, st_pos, end_pos, ne, max_flow;
  20. bool wh[maxn];
  22. int input;
  23. char a;
  25. static int read()
  26. {
  27.     a = getchar();
  28.     input = 0;
  29.     while(a < '0' || a > '9')   a = getchar();
  30.     while(a >= '0' && a <= '9')
  31.     {
  32.         input = input*10+a-'0';
  33.         a = getchar();
  34.     }
  35.     return input;
  36. }
  38. static void Init()
  39. {
  40.     int i, a, b, c, cur;
  41.     memset(num, -1, sizeof num);
  42.     n = read(), m = read(), st = read(), en = read();
  43.     for(i = 0; i != m; ++i)
  44.     {
  45.         cur = 2*i;
  46.         a = read(), b = read(), c = read();
  47.         flow[cur] = Edge(a, b, c);
  48.         flow[cur^1] = Edge(b, a, 0);
  49.         re[flow[cur].st][++num[flow[cur].st]] = cur;
  50.         re[flow[cur].en][++num[flow[cur].en]] = cur^1;
  51.     }
  52.     return ;
  53. }
  55. static bool Bfs(int st, int en)
  56. {
  57.     int i, j;
  58.     st_pos = -1, end_pos = 0;
  59.     memset(wh, 0, sizeof wh);
  60.     wh[st] = 1;
  61.     q[0] = st;
  62.     while(st_pos != end_pos)
  63.     {
  64.         curr_pos = q[++st_pos];
  65.         for(i = 0; i < num[curr_pos]+1; ++i)
  66.         {
  67.             j = re[curr_pos][i];
  68.             if(flow[j].st == curr_pos && flow[j].num > 0 && !wh[flow[j].en])
  69.             {
  70.                 ne = flow[j].en;
  71.                 wh[ne] = 1;
  72.                 pre[ne] = j;
  73.                 q[++end_pos] = flow[j].en;
  74.                 if(ne == en)
  75.                     return true;
  76.             }
  77.         }
  78.     }
  79.     return false;
  80. } 
  82. static int EK(int start_pos, int end_pos)
  83. {
  84.     int i, minn;
  85.     while(Bfs(start_pos, end_pos))
  86.     {
  87.         minn = INF;
  89.         for(i = end_pos; i != st; i = flow[pre[i]].st)
  90.         {
  91.             minn = min(minn, flow[pre[i]].num);
  92.         } 
  94.         for(i = end_pos; i != st; i = flow[pre[i]].st)
  95.         {
  96.             flow[pre[i]].num -= minn;
  97.             flow[pre[i]^1].num += minn;
  98.         }
  99.         max_flow += minn;
  100.     }
  101.     return max_flow;
  102. }
  104. int main()
  105. {
  106.     //freopen("test.in", "r", stdin);
  107.     //freopen("test.out", "w", stdout);
  109.     Init();
  110.     printf("%d", EK(st, en));
  112.     //fclose(stdin);
  113.     //fclose(stdout);
  114. }

最大流算法之EK（最短路径增广算法）的更多相关文章

  1. 【BZOJ-3638&3272&3267&3502】k-Maximum Subsequence Sum 费用流构图 + 线段树手动增广

    3638: Cf172 k-Maximum Subsequence Sum Time Limit: 50 Sec  Memory Limit: 256 MBSubmit: 174  Solved: 9 ...

  2. 【Luogu】P3381最小费用最大流模板（SPFA找增广路）

    题目链接 哈  学会最小费用最大流啦 思路是这样. 首先我们有一个贪心策略.如果我们每次找到单位费用和最短的一条增广路,那么显然我们可以把这条路添加到已有的流量里去——不管这条路的流量是多大,反正它能 ...

  3. python数据结构与算法——图的最短路径（Floyd-Warshall算法）

    使用Floyd-Warshall算法 求图两点之间的最短路径 不允许有负权边,时间复杂度高,思路简单 # 城市地图(字典的字典) # 字典的第1个键为起点城市,第2个键为目标城市其键值为两个城市间的直 ...

  4. python数据结构与算法——图的最短路径（Dijkstra算法）

    # Dijkstra算法——通过边实现松弛 # 指定一个点到其他各顶点的路径——单源最短路径 # 初始化图参数 G = {1:{1:0, 2:1, 3:12}, 2:{2:0, 3:9, 4:3}, ...

  5. python数据结构与算法——图的最短路径（Bellman-Ford算法）解决负权边

    # Bellman-Ford核心算法 # 对于一个包含n个顶点,m条边的图, 计算源点到任意点的最短距离 # 循环n-1轮,每轮对m条边进行一次松弛操作 # 定理: # 在一个含有n个顶点的图中,任意 ...

  6. POJ 1273 - Drainage Ditches - [最大流模板题] - [EK算法模板][Dinic算法模板 - 邻接表型]

    题目链接:http://poj.org/problem?id=1273 Time Limit: 1000MS Memory Limit: 10000K Description Every time i ...

  7. LOJ 2979 「THUSCH 2017」换桌——多路增广费用流

    题目:https://loj.ac/problem/2979 原来的思路: 优化连边.一看就是同一个桌子相邻座位之间连边.相邻桌子对应座位之间连边. 每个座位向它所属的桌子连边.然后每个人建一个点,向 ...

  8. 数据增广imgaug库的使用

    记录一下这两天用imgaug库做数据增广的代码,由于是算用算学的,所以只能把代码写出来,具体每种增广算法的原理和一些参数就不得而知了,不过我觉得也没必要把这么些个算法搜搞懂,毕竟重点是扩种数据.所以, ...

  9. 一般增广路方法求网络最大流（Ford-Fulkerson算法）

    /* Time:2015-6-18 接触网络流好几天了 写的第一个模版————Ford-Fulkerson算法 作用:求解网络最大流 注意:源点是0 汇点是1 如果题目输入的是1到n 请预处理减1 * ...

随机推荐

  1. java初学代码，还不太熟练

    奇数和 public class Homework01{ public static void main(String [] args){  long t=1,s=0; do{  s=s+t;  t= ...

  2. cuda编程学习4——Julia

    书上的例子编译会有错误,修改一下行即可. __device__ cuComplex(float a,float b):r(a),i(b){} /* ========================== ...

  3. Android Things教程：电气基础之直流电路理论

    译者注:由于本人水平有限,译文中难免会出现概念模糊.晦涩难懂,如果实在没心思看下去,请发挥你的学习能动性,到原文中自行翻译,感谢!!!点这里,直达英文各种长句的世界. 好了,既然你选择继续往下看,那就 ...

  4. 极客君教你破解隔壁妹子的wifi密码，成功率高达90%

    首先,给大家推荐一个我自己维护的网站: 开发者网址导航:http://www.dev666.com/ 破解wifi密码听起来很复杂,实际上也不是非常的复杂,极客君(微信公众帐号:极客峰)今天教大家如何 ...

  5. 深入React组件生命周期

    上篇博文使用React开发的一些注意要点对React开发的一些重点进行了简单的罗列总结,虽然也提到了React生命周期,但只略微小结,在此单独写篇React生命周期的总结. 在组件的整个生命周期中,随 ...

  6. icheck样式绑定与翻页保持

    官方文档:http://icheck.fronteed.com/ 使用基本样式 $('input').iCheck({ checkboxClass : 'icheckbox_square-blue', ...

  7. Debian 8开启sftp服务

    看到某云的CDN居然是使用ftp这种早该淘汰的协议,不禁有些吐槽.ftp曾经作为互联网上最重要的协议,但漫长使用过程中体现出的各种缺点,已不适合再使用.其中最致命的问题就是明文传输用户密码.建议使用这 ...

  8. 老李推荐：第14章3节《MonkeyRunner源码剖析》 HierarchyViewer实现原理-HierarchyViewer实例化

    老李推荐:第14章3节<MonkeyRunner源码剖析> HierarchyViewer实现原理-HierarchyViewer实例化 poptest是国内唯一一家培养测试开发工程师的培 ...

  9. 关于JavaScript的模块化

    为什么需要模块化 最近在学习网易微专业的<前端系统架构>课程,里面讲到了关于JavaScript的模块化问题.具体指的是当随着Web系统不断强大起来,需要在客户端进行的操作就多了起来(比如 ...

  10. Java与面向对象之随感(2)

    我们知道Java语言的一大特性就是相比于c语言和c++语言,其更加安全.那么Java安全性的一个重要保证就是它取消了指针,并且坚决反对数组的出界(c++对当数组超出上限但是还进行读写操作时允许的!), ...