网络流学习笔记
网络流,这个曾经只是专业知识的东西现在也逐渐进入寻常百姓家了。其实网络流并不神秘(但的确很神奇),可以将它理解为是一个管道网络,从一个源点出发,最后汇集到一个汇点,中间经过了许多容量大小不一的管道。一般来说,能抽象出网络流的题目在转成网络后求的不外乎是最大流(有时候也会求最小流,不过那是在流量有下界的时候),最小割,以及费用流。下面先对一些名词作简单的介绍:
1.流量限度:一个管道的极限流量,上限是最高流量,下限是最低流量。
2.残量网络:一个管道在已经流过一些流量以后还能流的流量。
3.反向边:设网络中非源非汇的两个顶点u、v,流量限度为c(u,v),先从u流向v f个流量(f<c(u,v)),然后设置一个流量为f的反向边从v流向u。反向边其实就是一条后路,以防你的程序选择了一条错误的道路却无法改正,在程序发现走错后就会从反向边走回来。“反向边的作用就是给程序一个反悔的机会”。
4.增广路:在残量网络中的一条从源点到汇点的路径,可以通过不断地增广来求最大流。
5.割:切断一些管道,使得从源点无法通向汇点,每一条被切断的管道的流量限度之和就是这个割的代价。
接下来是一些定理和性质:
1.流量守恒:除去源点和汇点外,流入其他任意一个节点的流量等于从这个点流出的流量,即每个节点都不会储存流量,开始从源点流出的流量最后一点都不剩的流进了汇点。
2.增广路定理:对于一个流f,在它的残量网络中再也找不到增广路,那么它就是原网络的最大流。
3.最小割最大流定理:一个网络中的最小割等于它的最大流。(这个非常重要,许多题目都是通过转成最小割,再转到求最大流上)
4.一条从源点到汇点的路的最大流量由这条路上的最小流量限制决定。
一、最大流
最大流是最基础的网络流算法,很多题目都是直接或间接地求网络的最大流,让我们从最基本的算法看起:
1.Ford-Fulkerson算法
这是求最大流的最基础的算法,不过因为它的时间复杂度比较高(O(n^4)),所以在实际应用中一般不用它,但是通过学习它,我们可以掌握最大流的基础求法,为后面学习SAP和DINIC打好基础。
FF算法的思想是现在原网络中找到一条从源点流向汇点的可行流,然后在残量网络中不断寻找增广路,直到没有增广路为止,根据增广路定理,可知此时已经找到了最大流。
以下的图可以十分形象的展示FF算法的运转过程:(注:图片摘自leolin_的专栏)
2.Edmonds-Karp算法(EK)
EK是以FF为基础的算法,只是对FF有了一些小的优化,就是用BFS的方法来求增广路,这样相比较起来会优一些。Ek就是通过不断用BFS增广,直到达到最大流,不过它的效率也不是很高(O(V E^2),V是点的数量,E是边的数量),所以一般都是把它当做练习,而实践中也不常用。
3.ISAP算法
重点来了,基本上大家都是使用这种方法解决最大流问题的,而且ISAP具有许多用力的优化,从而使得它具有良好的时间效率,同时编程的复杂度也不高,裸的代码(只加了一个优化)只有60行左右,通俗易懂。
优化:
1.gap优化:开一个gap数组保存距离,开始都是零,然后逐渐更新,当一次更新完后出现断层(gap[i]=0)时,这就代表源点到汇点之间已经不连通了,直接跳出。
2.邻接表优化:如果点的数量过多,邻接矩阵存不下了,就需要用到邻接表(当然也可以用next数组,写成链表也没有问题)。邻接表存储的是边的信息,一般存的是出发点,终点,价值和下一条边的序号。使用邻接表的话可以降低空间复杂度,但是会比较难写,所以邻接矩阵能存下就尽量写邻接矩阵吧。
3.当前弧优化:在使用邻接表增广的时候,保存第一个可行的弧,这样下次在搜到这条边的时候就直接从这个可行的弧开始搜起。
下面是只使用了gap优化的ISAP:
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
int n,m,a[101][101]={0},pre[101],dis[101]={0},gap[101]={0};
int ISAP(int S,int T)
{
memset(pre,-1,sizeof(pre));
pre[S]=S; gap[0]=T;
int minn,u=S,v,k,maxn=0;
while (dis[S]<T)
{
for (v=1; v<=T; v++)
if (dis[u]==dis[v]+1 && a[u][v]>0) break;
if (v<=T)
{
pre[v]=u; u=v;
if (v==T)
{
k=0x7fffffff;
for (int i=v; i!=S; i=pre[i])
k=min(k,a[pre[i]][i]);
maxn+=k;
for (int i=v; i!=S; i=pre[i])
{
a[pre[i]][i]-=k;
a[i][pre[i]]+=k;
}
u=S;
}
}
else
{
minn=T;
for (v=1; v<=T; v++)
if (a[u][v]>0) minn=min(minn,dis[v]);
gap[dis[u]]--;
if (!gap[dis[u]]) break;
dis[u]=minn+1; gap[dis[u]]++; u=pre[u];
}
}
return maxn;
}
int main()
{
scanf("%d%d",&n,&m);
for (int i=1; i<=m; i++)
{
int x,y,v;
scanf("%d%d%d",&x,&y,&v);
a[x][y]+=v;//邻接矩阵
}
printf("%d\n",ISAP(1,n));//此处1为源点,n为汇点
return 0;
}
4.预留推进算法(push_relabel)
预留推进算法经过优化就是压入重标记算法,先简述一下预留推进的思想,与其他算法相比,预留推进的一个最大特点是它每次都会给下一条边最大的流量(要么给到满,要么给到自己这里流量空了为止),这样一步一步推进。它会对每个节点维护一个高度,开始时源点高度最高,流量设为无穷大,然后向低的地方流下去,每次把向下已经流满却还有剩余流量的节点(源汇点除外)提升高度,使得能过继续流,如此往复,直到所有的非源非汇节点流量都变成零,此时算法结束,求出最大流。代码如下:
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;
int c[101][101],h[101],y[101],n;//c表示残量网络,h是高度函数,y是顶点的余流
void init()
{
scanf("%d",&n);
for (int i=1; i<=n; i++)
for (int j=1; j<=n; j++)
scanf("%d",&c[i][j]);
memset(h,0,sizeof(h));
memset(y,0,sizeof(y));
h[1]=n+1; y[1]=0x7fffffff;//此处1为源点,开始高度最高,余流为无穷大
}
int work(int s,int t)
{
int ans=0;
queue<int> qq;
qq.push(s);
while (!qq.empty())
{
int u=qq.front();
qq.pop();
for (int i=1; i<=t; i++)
{
int k;
if (c[u][i]<y[u]) k=c[u][i];
else k=y[u];
if (k>0 && (u==s || h[u]==h[i]+1))
{
c[u][i]-=k; c[i][u]+=k;
if (i==t) ans+=k;
y[u]-=k; y[i]+=k;
if (i!=s && i!=t) qq.push(i);
}
}
if (u!=s && u!=t && y[u]>0)//若还有余流,则提高高度,重新入队
{
h[u]++;
qq.push(u);
}
}
return ans;
}
int main()
{
init();//预处理
printf("%d\n",work(1,n));
return 0;
}
二、费用流(最小费用最大流)
费用流的求法与最大流求法相类似,这里不多描述,下面是邻接表实现的最小费用最大流模板(有借鉴神犇模板):
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
struct point
{
int v,cap,cost,next,reverse;
}edge[200001];
int n,m,ans=0,k,eh[200001],que[200001],pre[200001],dis[200001];
bool vis[200001];
void init()
{
memset(eh,0,sizeof(eh));
memset(que,0,sizeof(que));
memset(pre,-1,sizeof(pre));
memset(dis,0,sizeof(dis));
}
void add(int u,int v,int cap,int cost)
{
edge[k].v=v; edge[k].cap=cap; edge[k].cost=cost;
edge[k].next=eh[u]; edge[k].reverse=k+1;
eh[u]=k++;
edge[k].v=u; edge[k].cap=0; edge[k].cost=-cost;
edge[k].next=eh[v]; edge[k].reverse=k++;
}
bool spfa()
{
int head=0,tail=1;
for (int i=0; i<=n; i++)
{
dis[i]=0x7fffffff;
vis[i]=false;
}
dis[0]=que[0]=0; vis[0]=true;
while (head<tail)
{
int u=que[head++];
for (int i=eh[u]; i!=0; i=edge[i].next)
{
int v=edge[i].v;
if (edge[i].cap && dis[v]>dis[u]+edge[i].cost)
{
dis[v]=dis[u]+edge[i].cost;
pre[v]=i;
if (!vis[v])
{
vis[v]=true;
que[tail++]=v;
}
}
}
vis[u]=false;
}
if (dis[n]==0x7fffffff) return false;
return true;
}
void work()
{
int u,s=0x7fffffff;
for (u=n; u!=0; u=edge[edge[pre[u]].reverse].v)
s=min(s,edge[pre[u]].cap);
for (u=n; u!=0; u=edge[edge[pre[u]].reverse].v)
{
edge[pre[u]].cap-=s; edge[edge[pre[u]].reverse].cap+=s;
ans+=s*edge[pre[u]].cost;
}
}
int main()
{
scanf("%d%d",&n,&m);
init();
for (int i=1; i<=m; i++)
{
int x,y,cap,cost;
scanf("%d%d%d",&x,&y,&cap,&cost);
add(x,y,cap,cost); add(y,x,cap,cost);
}
while (spfa()) work();
printf("%d\n",ans);
return 0;
}
下面是邻接矩阵实现的:
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
int a[101][101],b[101][101];
int n,ans=0,k,que[101],pre[101],dis[101];
bool vis[101];
void init()
{
memset(que,0,sizeof(que));
memset(pre,-1,sizeof(pre));
memset(dis,0,sizeof(dis));
memset(a,0,sizeof(a));
memset(b,0,sizeof(b));
}
bool spfa()
{
int head=0,tail=1;
for (int i=0; i<=n; i++)
{
dis[i]=0x7fffffff;
vis[i]=false;
}
dis[0]=que[0]=0; vis[0]=true;
while (head<tail)
{
int u=que[head++];
for (int i=0; i<=n; i++)
if (a[u][i] && dis[i]>dis[u]+b[u][i])
{
dis[i]=dis[u]+b[u][i];
pre[i]=u;
if (!vis[i])
{
vis[i]=true;
que[tail++]=i;
if (tail==n) tail=0;
}
}
vis[u]=false;
head++;
if (head==n) head=0;
}
if (dis[n]==0x7fffffff) return false;
return true;
}
void work()
{
int s=0x7fffffff;
for (int u=n; u!=0; u=pre[u])
s=min(s,a[pre[u]][u]);
for (int u=n; u!=0; u=pre[u])
{
a[pre[u]][u]-=s; a[u][pre[u]]+=s;
ans+=s*b[pre[u]][u];
}
}
int main()
{
scanf("%d",&n);
init();
for (int i=1; i<=n; i++)
for (int j=1; j<=n; j++)
scanf("%d%d",&a[i][j],&b[i][j]);
while (spfa()) work();
printf("%d\n",ans);
return 0;
}
最后,总结一下个人做题经验:在做网络流题目的时候, 建模是最重要的,只要建好了模,直接修改模板即可。还是要多练习才能掌握技巧。