网络流模板
在这里我只放我的模板和一些我个人的“理解”。。
最大流测试题：usaco草地排水
EK：
时间复杂度：O(VE^2)
代码复杂度：最易
代码：
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
#define CLR(a) memset(a, 0, sizeof(a))
#define FOR(i,a,n) for(i=a;i<=n;++i)
const int maxn = 205, oo = ~0u >> 1;
int cap[maxn][maxn], ihead[maxn], inext[maxn<<2], iv[maxn<<2], cnt;
int p[maxn];
queue<int> q;
int n, m;
int min(const int& a, const int& b) { return a < b ? a : b; }
int EK(int s, int t) {
int u, v, i, flow = 0, aug;
while(1) {
CLR(p);
q.push(s);
while(!q.empty()) {
u = q.front(); q.pop();
for(i = ihead[u]; i ; i = inext[i]) if(cap[u][iv[i]] > 0 && !p[iv[i]]) {
p[iv[i]] = u; q.push(iv[i]);
}
}
if(!p[t]) break;
aug = oo;
for(v = t; v != s; v = p[v]) aug = min(aug, cap[p[v]][v]);
for(v = t; v != s; v = p[v]) cap[p[v]][v] -= aug, cap[v][p[v]] += aug;
flow += aug;
}
return flow;
}
void add(int u, int v, int c) {
inext[++cnt] = ihead[u]; ihead[u] = cnt; iv[cnt] = v;
cap[u][v] += c;
inext[++cnt] = ihead[v]; ihead[v] = cnt; iv[cnt] = u;
}
int main() {
scanf("%d%d", &m, &n);
int u, v, c;
for(int i = 1; i <= m; ++i) {
scanf("%d%d%d", &u, &v, &c);
add(u, v, c);
}
printf("%d", EK(1, n));
return 0;
}
Dinic:
时间复杂度：O(V^2E)
代码复杂度：较长但不易出错
PS：这是加了当前弧优化的
代码1（这份代码的cap是二维的）：
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
#define CLR(a) memset(a, 0, sizeof(a))
#define FOR(i,a,n) for(i=a;i<=n;++i)
const int maxn=205, oo=~0u>>1, maxm=maxn<<2;
int cap[maxn][maxn], ihead[maxn], inext[maxm], iv[maxm], cnt;
int vis[maxn], d[maxn], cur[maxn];
queue<int> q;
int n, m, s, t;
int min(const int& a, const int& b) { return a < b ? a : b; }
bool BFS() { //建立层次图
CLR(vis);
q.push(s); d[s]=0; vis[s]=1; //这里记住要加上vis[s]=1;
int u, i;
while(!q.empty()) {
u=q.front(); q.pop();
for(i=ihead[u]; i; i=inext[i]) if(!vis[iv[i]] && cap[u][iv[i]]) { d[iv[i]]=d[u]+1; vis[iv[i]]=1; q.push(iv[i]); }
}
return vis[t];
}
int DFS(int u, int a) {
if(u==t || !a) return a;
int f, flow=0;
for(int& i=cur[u]; i; i=inext[i])
if(d[u]+1==d[iv[i]] && (f=DFS(iv[i], min(a, cap[u][iv[i]])))>0 ) { //沿着层次图走，并且这是条增广路
flow+=f, a-=f, cap[u][iv[i]]-=f, cap[iv[i]][u]+=f;//a保存的是之前路径的最小，所以不一定是等于f，所以要减掉f
if(!a) break; //说明不可能再有增广路，也就是说，前面断了。
}
return flow;
}
int dinic() {
int flow=0, i;
while(BFS()) {
FOR(i, 1, n) cur[i]=ihead[i];
flow+=DFS(s, oo);
}
return flow;
}
void add(int u, int v, int c) {
inext[++cnt]=ihead[u]; ihead[u]=cnt; iv[cnt]=v;
cap[u][v]+=c;
inext[++cnt]=ihead[v]; ihead[v]=cnt; iv[cnt]=u;
}
int main() {
scanf("%d%d", &m, &n);
int u, v, c;
for(int i=1; i<=m; ++i) {
scanf("%d%d%d", &u, &v, &c);
add(u, v, c);
}
s=1; t=n;
printf("%d", dinic());
return 0;
}
代码2（cap已改为1维，并做了相应更改）：
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
#define CC(a, c) memset(a, c, sizeof(a))
#define FOR(i,a,n) for(i=a;i<=n;++i)
const int maxn=300, oo=~0u>>1, maxm=50000;
int S, T, cap[maxm], d[maxn], cur[maxn], vis[maxn];
queue<int> q;
int N, ihead[maxn], inext[maxm], to[maxm], from[maxm], cnt; //听取wyl意见，从2开始编号
int min(const int& a, const int& b) { return a < b ? a : b; }
bool BFS() { //建立层次图
CC(vis, 0);
q.push(S); d[S]=0; vis[S]=1; //这里记住要加上vis[s]=1;
int u, i;
while(!q.empty()) {
u=q.front(); q.pop();
for(i=ihead[u]; i; i=inext[i]) if(!vis[to[i]] && cap[i]) { d[to[i]]=d[u]+1; vis[to[i]]=1; q.push(to[i]); }
}
return vis[T];
}
int DFS(int u, int a) {
if(u==T || !a) return a;
int f, flow=0;
for(int& i=cur[u]; i; i=inext[i])
if(d[u]+1==d[to[i]] && (f=DFS(to[i], min(a, cap[i])))>0 ) { //沿着层次图走，并且这是条增广路
flow+=f, a-=f, cap[i]-=f, cap[i^1]+=f;//a保存的是之前路径的最小，所以不一定是等于f，所以要减掉f
if(!a) break; //说明不可能再有增广路，也就是说，前面断了。
}
return flow;
}
int dinic() {
int flow=0, i;
while(BFS()) {
FOR(i, 1, N) cur[i]=ihead[i];
flow+=DFS(S, oo);
}
return flow;
}
void add(int u, int v, int c) {
inext[++cnt]=ihead[u]; ihead[u]=cnt; to[cnt]=v; cap[cnt]=c;
inext[++cnt]=ihead[v]; ihead[v]=cnt; to[cnt]=u;
}
void init(int s, int t, int n) {
S=s; T=t; N=n; cnt=1;
CC(ihead, 0);
}
int main() {
int n, m, u, v, c, i;
scanf("%d%d", &m, &n);
init(1, n, n);
for(i=1; i<=m; ++i) {
scanf("%d%d%d", &u, &v, &c);
add(u, v, c);
}
printf("%d", dinic());
return 0;
}
isap（国人都叫sap，其实百度一下有解释的）：
时间复杂度：O(V^2E)实际快多了，这是我将来用的算法
代码复杂度：短但细节太多，易错
PS：这是加了当前弧优化、gap优化的、暂无瓶颈优化 | 话说，调sap我都调怕了，有点恐惧症了。。
代码1（容量我还是用二维的存）：
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
#define CC(a, c) memset(a, c, sizeof(a))
#define FOR(i,a,n) for(i=a;i<=n;++i)
const int maxn=205, oo=~0u>>1, maxm=maxn<<2;
int cap[maxn][maxn], ihead[maxn], inext[maxm], iv[maxm], cnt;
int p[maxn], d[maxn], cur[maxn], gap[maxn];
int n, m, s, t;
int min(const int& a, const int& b) { return a < b ? a : b; }
int isap() {
int flow=0, u, v, i, f=oo;
CC(d, 0); CC(gap, 0);
for(i=1; i<=n; ++i) cur[i]=ihead[i];
u=p[s]=s; gap[0]=n; //这里预处理很重要，第一个赋值给p[s]是因为后面会调用，第二个是因为没有单独的bfs来处理d数组才要这样设置，否则一两次循环就要跳出了
while(d[s]<n) {
for(i=cur[u]; i; i=inext[i]) if(cap[u][iv[i]] && d[u]==d[iv[i]]+1) break;
if(i) {
cur[u]=i; v=iv[i]; f=min(f, cap[u][v]); p[v]=u; u=v; //这里记得将u重新赋值过，cur当前弧优化
if(v==t) {
for(; v!=s; v=p[v]) cap[p[v]][v]-=f, cap[v][p[v]]+=f;
u=s; flow+=f; f=oo; //将u退回远点，似乎有叫瓶颈优化的东西，到时候再说吧。记得将最小流f重置
}
}
else {
if( !(--gap[d[u]]) ) break; //gap优化，即发现断层立即终止
d[u]=n; //当没有发现允许弧时，要重新设置
cur[u]=ihead[u]; //这里最坑，，，还是请大神帮忙调试出来的0 0，应该这里是瓶颈优化的地方
for(i=cur[u]; i; i=inext[i]) if(cap[u][iv[i]] && d[u]>d[iv[i]]+1) d[u]=d[iv[i]]+1;
gap[d[u]]++; u=p[u];
}
}
return flow;
}
void add(int u, int v, int c) {
inext[++cnt]=ihead[u]; ihead[u]=cnt; iv[cnt]=v; cap[u][v]+=c;
inext[++cnt]=ihead[v]; ihead[v]=cnt; iv[cnt]=u;
}
int main() {
scanf("%d%d", &m, &n);
int u, v, c, i;
for(i=1; i<=m; ++i) {
scanf("%d%d%d", &u, &v, &c);
add(u, v, c);
}
s=1; t=n;
printf("%d", isap());
return 0;
}
代码2（已改为1维并相应修改）：
#include <cstdio>
#include <cstring>
using namespace std;
#define CC(a, c) memset(a, c, sizeof(a))
#define FOR(i,a,n) for(i=a;i<=n;++i)
//听取wyl意见，从2开始编号
const int maxn=1000, maxm=1000000, oo=100000000;
int cap[maxm], d[maxn], cur[maxn], gap[maxn], p[maxn];
int ihead[maxn], inext[maxm], to[maxm], from[maxm], cnt;
int min(const int& a, const int& b) { return a < b ? a : b; }
int isap(int s, int t, int n) {
int flow=0, i, u, f=oo;
CC(gap, 0); CC(d, 0);
FOR(i, 0, n) cur[i]=ihead[i];
u=s; gap[0]=n; //这里预处理很重要，第二个是因为没有单独的bfs来处理d数组才要这样设置，否则一两次循环就要跳出了
while(d[s]<n) {
for(i=cur[u]; i; i=inext[i]) if(cap[i] && d[u]==d[to[i]]+1) break;
if(i) {
cur[u]=i; f=min(f, cap[i]); p[to[i]]=i; u=to[i]; //这里记得将u重新赋值过，cur当前弧优化 //这里注意，p要赋值成i
if(u==t) {
for(; u!=s; u=from[p[u]]) cap[p[u]]-=f, cap[p[u]^1]+=f;
flow+=f; f=oo;
}
}
else {
if( !(--gap[d[u]]) ) break; //gap优化，即发现断层立即终止
d[u]=n; //当没有发现允许弧时，要重新设置
cur[u]=ihead[u]; //这里最坑，，，还是请大神帮忙调试出来的0 0，应该这里是瓶颈优化的地方
for(i=cur[u]; i; i=inext[i]) if(cap[i] && d[u]>d[to[i]]+1)
d[u]=d[to[i]]+1;
gap[d[u]]++; if(u!=s) u=from[p[u]];//这里要注意
}
}
return flow;
}
void add(int u, int v, int c) {
inext[++cnt]=ihead[u]; ihead[u]=cnt; from[cnt]=u; to[cnt]=v; cap[cnt]=c;
inext[++cnt]=ihead[v]; ihead[v]=cnt; from[cnt]=v; to[cnt]=u; cap[cnt]=0;
}
void init() {
cnt=1; CC(ihead, 0);
}
int main() {
int n, m, u, v, c, i;
scanf("%d%d", &m, &n);
init();
for(i=1; i<=m; ++i) {
scanf("%d%d%d", &u, &v, &c);
add(u, v, c);
}
printf("%d", isap(1, n, n));
return 0;
}
代码3（根据大神的指点，优化了求增广流f）：
#include <cstdio>
#include <cstring>
using namespace std;
#define CC(a, c) memset(a, c, sizeof(a))
#define FOR(i,a,n) for(i=a;i<=n;++i)
//听取wyl意见，从2开始编号
const int maxn=1000, maxm=1000000, oo=100000000;
int cap[maxm], d[maxn], cur[maxn], gap[maxn], p[maxn];
int ihead[maxn], inext[maxm], to[maxm], from[maxm], cnt;
int min(const int& a, const int& b) { return a < b ? a : b; }
int isap(int s, int t, int n) {
int flow=0, i, u, f=oo;
CC(gap, 0); CC(d, 0);
FOR(i, 0, n) cur[i]=ihead[i];
u=s; gap[0]=n; //这里预处理很重要，第二个是因为没有单独的bfs来处理d数组才要这样设置，否则一两次循环就要跳出了
while(d[s]<n) {
for(i=cur[u]; i; i=inext[i]) if(cap[i] && d[u]==d[to[i]]+1) break;
if(i) {
cur[u]=i; p[to[i]]=i; u=to[i]; //这里记得将u重新赋值过，cur当前弧优化 这里注意，p要赋值成i
if(u==t) {
for(f=oo; u!=s; u=from[p[u]]) f=min(f, cap[p[u]]); //还是这样优化吧，开个数组和这样差不多；如果在前面min的话，会找同一增广路几次
for(u=t; u!=s; u=from[p[u]]) cap[p[u]]-=f, cap[p[u]^1]+=f;
flow+=f;
}
}
else {
if( !(--gap[d[u]]) ) break; //gap优化，即发现断层立即终止
d[u]=n; //当没有发现允许弧时，要重新设置
cur[u]=ihead[u]; //这里最坑，，，还是请大神帮忙调试出来的0 0，应该这里是瓶颈优化的地方
for(i=cur[u]; i; i=inext[i]) if(cap[i] && d[u]>d[to[i]]+1)
d[u]=d[to[i]]+1;
gap[d[u]]++; if(u!=s) u=from[p[u]];//这里要注意
}
}
return flow;
}
void add(int u, int v, int c) {
inext[++cnt]=ihead[u]; ihead[u]=cnt; from[cnt]=u; to[cnt]=v; cap[cnt]=c;
inext[++cnt]=ihead[v]; ihead[v]=cnt; from[cnt]=v; to[cnt]=u; cap[cnt]=0;
}
void init() {
cnt=1; CC(ihead, 0);
}
int main() {
int n, m, u, v, c, i;
scanf("%d%d", &m, &n);
init();
for(i=1; i<=m; ++i) {
scanf("%d%d%d", &u, &v, &c);
add(u, v, c);
}
printf("%d", isap(1, n, n));
return 0;
}
我自己的瞎扯：
-
网络流为什么要有反向弧：
最直观的是= =，如果自己原来的弧的点被其它的s-t占掉了，还可以通过反向弧从占掉那个点的弧（u，v）中的u流回去，去占它的点，从而构成一条新的s-t -
isap的Gap优化的解释：
断层这个概念，可以这样想：
b
/
a -- c
\
d
这里我们假设d(a)=5
此时假设b后的增广路已经完了，那么d(b) = n，但是我们发现，还有d(c)=4，即没有断层。
一直下去，直到d(c)和d(d)都为n了，此时没有一个d(i)=4，所以，发生断层，此时d(i)=4的数目为0，所以就可以结束程序了。
这就是所谓的Gap优化～ -
网络流这一类题的初始化：
首先就要将所有点和该连的弧给连了，否则容易出错，什么拆点啊这些操作首先搞掉。
-
网络流上下界的胡扯解释：
为什么一条边(u,v)的的下界是从附加源连到v呢？
我是这样认为的： 从源开始流，又流回了u，再流回汇，如果满了，就能判断了0.0
同理，将u连到了汇上。。而汇到源连一条无限容量的弧是为了让那个下界流从这里流回去。。-（在无源无汇的话其实可以不必连这条边）