网络流算法总结 Edmond-Krap + SAP（GAP优化）+Dinic

花了几天来学最大流问题，折腾的我头都晕了，下面就来让我做个总结。

首先介绍一下网络流，流网络G=(V,E)是一个有向图，其中每条边又有一个非负容量c(u,v)>=0,如果存在一条边(u,v)不属于G，那么可以认为c(u,v)=0。网络流中两个点，s(源点)和e(汇点)。

一、网络流的三个性质 ：

1、容量限制: f(u,v)<=c(u,v)

2、反对称性：f(u,v) = - f(v,u)

3、流量平衡: 对于不是源点也不是汇点的任意结点,流入该结点的流量和等于流出该结点的流量和。

二、下面介绍一下残留网络和增广网络：

1、残留网络：对于网络G=(V,E,C)，设流f是G中的流。残留网络是由还可以容纳更多的流的边组成。

Cf(u,v)=C(u,v)-f(u,v)
2、增广路：增广路p为残留网络Gf上的源s到汇e上一条简单路径。该路径的残留容量为可以沿该路径增加的额外流量。
三、最小割最大流定理：
网络 G = (V,E,C)中的割[S,T]将点集V划分为S、T两个部分，使得s(源点)在S中，而e(汇点)在T中。符号[S,T]代表集合{<u,v>|<u,v>,s属于S,e属于T}，穿过割[S,T]的净流量定义为f(S,T),割[S,T]的容量定义为c(S,T)。
如果f是具有源s和汇e的网络G=(V,E,C)中的一个流，则下列条件是等价的：
(1)f是G的一个最大流
(2)残留网络Gf不包含增广路径
(3)对G的某个割[S,T],有|f|=c(S,T)

下面来介绍3种算法：
一、Edmond-Karp：
1、在残留网络中找到一条从源点到汇点的增广路，如果找到转向(2)，没有转向(4)。
2、找到路径中最小的边:min，记录下来，累加到最大流中转向(3)。
3、增广路中所有c<u,v>减去min,所有c<u,v>加上min，重构新的残留网络，转向(2)。
4、得到最大流

#include<iostream>
using namespace std;
const int inf =0x7ffffff;
const int MAXN = 210;
int map[MAXN][MAXN],n,val[MAXN],queue[MAXN];
bool bfs(int s,int e)
{
int top(0),base(0);
bool vis[MAXN];
memset(vis,false,sizeof(vis));
memset(val,-1,sizeof(val));
queue[top++] = s;
vis[s] = true;
while(top!=base)
{
int a = queue[base];
if(a == e)
return true;
base++;
for(int i=1;i!=n+1;++i)
{
if(map[a][i]&&!vis[i])
{
vis[i] = true;
val[i] = a;
queue[top++] = i;
}
}
}
return false;
}
int main()
{
int e;
while(cin>>e>>n)
{
int u,flow(0),max;
memset(map,0,sizeof(map));
while(e--)
{
int a,b,c;
cin>>a>>b>>c;
map[a][b]+=c;
}
while(bfs(1,n))
{
max = inf;
u = n;
while(val[u]!=-1)
{
max = (max>map[val[u]][u])?map[val[u]][u]:max;
u = val[u];
}
flow+=max;
u = n;
while(val[u]!=-1)
{
map[val[u]][u]-=max;
map[u][val[u]]+=max;
u = val[u];
}
}
cout<<flow<<endl;
}
}

二、Dinic：

1.分层：利用BFS搜索方式给每个节点给予标记level[i]；

2.判断分层是否成功即汇点是否被分到级别level[sink]!=0；

3.在分层的基础上即level[i]上寻找所有的增广路、累计流量，回到步骤1；

#include<iostream>
#include<queue>
using namespace std;
const int inf = 0x7fffffff;
const int MAXN = 210;
int map[MAXN][MAXN];
int level[MAXN];
int n, m;
int s, e;
bool bfs()//对顶点进行标号，找出层次图
{
queue<int> Q;
while (!Q.empty())
Q.pop();
memset(level, 0, sizeof(level));
Q.push(s);
level[s] = 1;
int u, v;
while (!Q.empty())
{
u = Q.front();
Q.pop();
for (v = 1; v <= n; ++v)
{
if (!level[v] && map[u][v] > 0)
{
level[v] = level[u] + 1;
Q.push(v);
}
}
}
return level[e] != 0;//汇点是否在层次图中
}
int dfs(int u, int cp)//在层次图中寻找增广路径进行增广
{
int tmp = cp;
int v, t;
if (u == e)
return cp;
for (v = 1; v <= n && tmp; ++v)
{
if (level[v] == level[u] + 1 && map[u][v] > 0)
{
t = dfs(v, min(tmp, map[u][v]));
map[u][v] -= t;
map[v][u] += t;
tmp -= t;
}
}
return cp - tmp;
}
int dinic()
{
int ans, flow;
ans = flow = 0;
while (bfs())//汇点不在层次图中，算法终止
{
while (flow = dfs(1, inf))
{
ans += flow;
}
}
return ans;
}
int main()
{
int i, u, v, cost;
while(cin>>m>>n)
{
s = 1;
e = n;
memset(map, 0, sizeof(map));
for(i = 0; i < m; i++)
{
cin >> u >> v >> cost;
map[u][v] += cost;
}
cout<<dinic()<<endl;;
}
return 0;
}

三、SAP+GAP

1.给每个点标高度 只有高处的水才能往地处流 一开始的高度都为0

2.在所有的可行弧中不断的寻找增广路 可行弧的定义为 {(i,j) | dis[i]=dis[j]+1}

3.遍历完当前节点后（流不出去了） 重新标记当前点的高度（保证下次再来的时候有路可走） dis[i]=min(dis[j])+1;

4.检查是否存在断层 如果出现断层 则图中已不存在增广路 算法可以结束 否则从源点开始继续遍历

#include<iostream>
using namespace std;
const int inf = 0x7fffffff;
const int MAXN = 210;
const int MAXM = MAXN*MAXN;
int map[MAXN][MAXN];
int dis[MAXN];
int queue[MAXM];
int bef[MAXN];
int num[MAXN];
void set_dis(int end)
{
int top(0),base(0);
memset(dis,-1,sizeof(dis));
memset(num,0,sizeof(num));
queue[top++] = end;
dis[end]=0;num[0] = 1;
while(top!=base)
{
int pre = queue[base++];
for(int i=end-1;i!=0;i--)
{
if(dis[i] != -1 || map[i][pre] == 0)
continue;
dis[i] = dis[pre]+1;
queue[top++] = i;
num[dis[i]]++;
}
}
}
int cmp(int x,int y)
{
if(x<y)
return x;
return y;
}
int remark(int n,int a)
{
int tmp=inf;
for(int i=1;i!=n+1;i++)
if(map[a][i]!=0&&dis[i]>=0)
tmp=cmp(tmp,dis[i]+1);
if(tmp==inf)
tmp=n;
return tmp;
}
int SAP(int n,int s)
{
int j,a = s;int flow(0);
memset(bef,-1,sizeof(bef));
while(dis[s]<n)
{
for(j=1;j!=n+1;j++)
{
if(map[a][j]>0&&dis[a]-1==dis[j])
{
break;
}
}
if(j<=n)
{
bef[j] = a;a = j;
if(a==n)
{
int i = n,max(inf);
while(bef[i]!=-1)
{
max = cmp(max,map[bef[i]][i]);
i = bef[i];
}
i = n;
while(bef[i]!=-1)
{
map[bef[i]][i]-=max;
map[i][bef[i]]+=max;
i = bef[i];
}
flow+=max;a=s;
}
}
else
{
int x = remark(n,a);
num[x]++;num[dis[a]]--;
if(num[dis[a]]==0)
return flow;//间隙优化 gap
dis[a]=x;
if(a!=s)
a=bef[a];
}
}
return flow;
}
int main()
{
int e,n;
//cout<<inf<<endl;
while(cin>>e>>n)
{
memset(map,0,sizeof(map));
while(e--)
{
int a,b,w;
cin>>a>>b>>w;
map[a][b] += w;
}
set_dis(n);
cout<<SAP(n,1)<<endl;
}
return 0;
}