2171. EK求最大流，最大流算法
给定一个包含 n 个点 m 条边的有向图，并给定每条边的容量，边的容量非负。
图中可能存在重边和自环。求从点 S 到点 T 的最大流。
输入格式
第一行包含四个整数 n,m,S,T
接下来 m 行，每行三个整数 u,v,c，表示从点 u 到点 v 存在一条有向边，容量为 c。
点的编号从 1 到 n。
输出格式
输出点 S 到点 T 的最大流。
如果从点 S 无法到达点 T 则输出 0。
数据范围
2≤n≤1000
1≤m≤10000
0≤c≤10000
S≠T
输入样例：
7 14 1 7
1 2 5
1 3 6
1 4 5
2 3 2
2 5 3
3 2 2
3 4 3
3 5 3
3 6 7
4 6 5
5 6 1
6 5 1
5 7 8
6 7 7
输出样例：
14解析：EK模板题
Ford-Fulkerson Algorithm 寻找网络最大流：
最外情况下循环次数等最大流的大小；
最坏情况下的 时间复杂度 O(fm);
f:表示最大流
m:表示边（寻找简单路径花费的时间）
Ford-Fulkerson Algorithm 寻找网络最大流：
1.创建一个residual graph,初始的residual graph的每条边的容量等于原图边的容量
2.做循环：
a.在residual graph中寻找从起点到终点的简单路径
b.寻找这条路径上的最小权重x，即为该路径的容量
c.更新residual graph（路径上的所有权值都减去该路径的流量，即为b中的x）
d.添加一条反向路径（路径上的权重都等于x）
EK算法与Ford-Fulkerson几乎完全一样，唯一的区别是EK算法寻找简单路径的时候要用最短路算法，且将所有权值当作1
时间复杂度是 O(n*m^2),m是边数，n是点数
使用EK算法的技巧：
1.我们使用链式前向星建的图，这里我们一开始就建好每条边的反向边，且每条边的反向边与正向边相邻，如 i=0 存正向边，那么 i=1 存反向边，这样求一条边的反向边只需要按为 取反即可
2.求最短路时，因为每条边的权值为 1 ，所以我们直接使用 bfs 求最短路即可
3.因为我们每次求完一条简单路径后需要将每单路径上的所有边都减去流量，反边加上流量，所以我们需要使用 pre 数组来存储前驱。这里 pre 存储边而非节点。
#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
using namespace std;
typedef long long LL;
const int N = 1e3 + 5, M = 2e4 + 5, inf = 0x3f3f3f3f;
int n, m, S, T;
int h[N], e[M], w[M], ne[M], idx;
int q[N], pre[N], d[N];
bool v[N];
void add(int a, int b, int c) {
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
e[idx] = a, w[idx] = 0, ne[idx] = h[b], h[b] = idx++;
}
int bfs() {
int hh = 0, tt = 0;
memset(v, 0, sizeof v);
q[0] = S, v[S] = 1, d[S] = inf;
while (hh <= tt) {
int t = q[hh++];
for (int i = h[t]; i != -1; i = ne[i]) {
int j = e[i];
if (!v[j] && w[i]) {
v[j] = 1;
d[j] = min(d[t], w[i]);
pre[j] = i;
if (j == T)return 1;
q[++tt] = j;
}
}
}
return 0;
}
int EK() {
int ret = 0;
while (bfs()) {
ret += d[T];
for (int i = T; i != S; i = e[pre[i] ^ 1]) {
w[pre[i]] -= d[T], w[pre[i] ^ 1] += d[T];
}
}
return ret;
}
int main() {
memset(h, -1, sizeof h);
scanf("%d%d%d%d", &n, &m, &S, &T);
for (int i = 1,a,b,c; i <= m; i++) {
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
printf("%d\n", EK());
return 0;
}
#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
#include<sstream>
#include<deque>
#include<unordered_map>
using namespace std;
const int N = 1e3 + 5, M = 2e4 + 5;
int n, m, S, T;
int h[N], e[M],f[M], ne[M], idx;
int pre[N], d[N];
bool vis[N];
/*
使用EK算法的技巧：
1.我们使用链式前向星建的图，这里我们一开始就建好每条边的反向边，且每条边的反向边与正向边相邻，如 i=0 存正向边，那么 i=1 存反向边，这样求一条边的反向边只需要按为 取反即可
2.求最短路时，因为每条边的权值为 1 ，所以我们直接使用 bfs 求最短路即可
3.因为我们每次求完一条简单路径后需要将每单路径上的所有边都减去流量，反边加上流量，所以我们需要使用 pre 数组来存储前驱。这里 pre 存储边而非节点。
*/
void add(int a, int b, int c) {
e[idx] = b, f[idx] = c, ne[idx] = h[a], h[a] = idx++;
e[idx] = a, f[idx] = 0, ne[idx] = h[b], h[b] = idx++;
}
bool bfs() {
queue<int>q;
memset(vis, 0, sizeof vis);
q.push(S);
vis[S] = 1;
d[S] = 1e8;
while (!q.empty()) {
int t = q.front();
q.pop();
for (int i = h[t]; i != -1; i = ne[i]) {
int ver = e[i];
if (!vis[ver]&&f[i]) {
d[ver] = min(d[t], f[i]);
pre[ver] = i;
if (ver == T) { return 1; }
q.push(ver);
vis[ver] = 1;
}
}
}
return 0;
}
int EK() {
int ret = 0;
while (bfs()) {
//cout << "LLLLLLLLLLL" << endl;
ret += d[T];
for (int i = T; i != S;i=e[pre[i]^1]) {
f[pre[i]] -= d[T], f[pre[i]^1] += d[T];
}
}
return ret;
}
int main() {
scanf("%d%d%d%d", &n, &m, &S, &T);
memset(h, -1, sizeof h);
for (int i = 1,a,b,c; i <= m; i++) {
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
printf("%d\n", EK());
return 0;
}
Dinic算法：
1.创建一个residual graph,初始的residual graph的每条边的容量等于原图边的容量
2.循环：
a.构造level grahp（可以理解为层次遍历的图，保留层与层之间的边）
b.在level grahp寻找阻塞流
c.更新residual graph
时间复杂度 O(m*n^2):这说明Dinic算法通常比EK算法快
