在算法导论中对求解最大流问题给出了一般性的解决方法，但并没有涉及到具体的实现。在这里我还是重新的对求解最大流的思想进行一般性的描述，然后再给出具体的实现。
Ford-Fulkerson方法依赖于三种重要思想，这三个思想就是在上一篇网络流基础中提到的：残留网络，增广路径和割。Ford-Fulkerson方法是一种迭代的方法。开始时，对所有的u，v∈V有f(u,v)=0，即初始状态时流的值为0。在每次迭代中，可通过寻找一条“增广路径”来增加流值。增广路径可以看成是从源点s到汇点t之间的一条路径，沿该路径可以压入更多的流，从而增加流的值。反复进行这一过程，直至增广路径都被找出来，根据最大流最小割定理，当不包含增广路径时，f是G中的一个最大流。在算法导论中给出的Ford-Fulkerson实现代码如下：
FORD_FULKERSON(G,s,t)
1 for each edge(u,v)∈E[G]
2 do f[u,v] <— 0
3 f[v,u] <— 0
4 while there exists a path p from s to t in the residual network Gf
5 do cf(p) <— min{ cf(u,v) : (u,v) is in p }
6 for each edge(u,v) in p
7 do f[u,v] <— f[u,v]+cf(p) //对于在增广路径上的正向的边，加上增加的流
8 f[v,u] <— -f[u,v] //对于反向的边，根据反对称性求
第1~3行初始化各条边的流为0，第4~8就是不断在残留网络Gf中寻找增广路径，并沿着增广路径的方向更新流的值，直到找不到增广路径为止。而最后的最大流也就是每次增加的流值cf(p)之和。在实际的实现过程中，我们可以对上述代码做些调整来达到更好的效果。如果我们采用上面的方法，我们就要保存两个数组，一个是每条边的容量数组c，一个就是上面的每条边的流值数组f，在增广路径中判断顶点u到v是否相同时我们必须判断c[u][v]-f[u][v]是否大于0，但是因为在寻找增广路径时是对残留网络进行查找，所以我们可以只保存一个数组c来表示残留网络的每条边的容量就可以了，这样我们在2~3行的初始化时，初始化每条边的残留网络的容量为G的每条边的容量（因为每条边的初始流值为0）。而更新时，改变7~8行的操作，对于在残留网络上的边(u,v)执行c[u][v]-=cf(p)，而对其反向的边(v,u)执行c[v][u]+=cf(p)即可。
现在剩下的最关键问题就是如何寻找增广路径。而Ford-Fulkerson方法的运行时间也取决于如何确定第4行中的增广路径。如果选择的方法不好，就有可能每次增加的流非常少，而算法运行时间非常长，甚至无法终止。对增广路径的寻找方法的不同形成了求最大流的不同算法，这也是Ford-Fulkerson被称之为“方法”而不是“算法”的原因。下面将给出Ford-Fulkerson方法的具体实现细节：
int c[MAX][MAX]; //残留网络容量
int pre[MAX]; //保存增广路径上的点的前驱顶点
bool visit[MAX];
int Ford_Fulkerson(int src,int des,int n){ //src：源点 des：汇点 n：顶点个数
int i,_min,total=0;
while(true){
if(!Augmenting_Path(src,des,n))return total; //如果找不到增广路就返回，在具体实现时替换函数名
_min=(1<<30);
i=des;
while(i!=src){ //通过pre数组查找增广路径上的边，求出残留容量的最小值
if(_min>c[pre[i]][i])_min=c[pre[i]][i];
i=pre[i];
}
i=des;
while(i!=src){ //再次遍历，更新增广路径上边的流值
c[pre[i]][i]-=_min;
c[i][pre[i]]+=_min;
i=pre[i];
}
total+=_min; //每次加上更新的值
}
}
Edmonds-Karp算法实际上就是采用广度优先搜索来实现对增广路径的p的计算，代码如下：
bool Edmonds_Karp(int src,int des,int n){
int v,i;
for(i=0;i<n;i++)visit[i]=false;
front=rear=0; //初始化
que[rear++]=src;
visit[src]=true;
while(front!=rear){ //将源点进队后开始广搜的操作
v=que[front++];
//这里如果采用邻接表的链表实现会有更好的效率，但是要注意(u,v)或(v,u)有任何一条
//边存在于原网络流中，那么邻接表中既要包含(u,v)也要包含(v,u)
for(i=0;i<n;i++){
if(!visit[i]&&c[v][i]){ //只有残留容量大于0时才存在边
que[rear++]=i;
visit[i]=true;
pre[i]=v;
if(i==des)return true; //如果已经到达汇点，说明存在增广路径返回true
}
}
}
return false;
}
层次图
短路增值算法(MPLA)
算法流程
汇点不在层次图内意味着在剩余图中不存在一条从源点到汇点的路径，即没有增广路。
在程序实现的时候，层次图并不用被“建”出来，我们只需对每个顶点标记层次，增广的时候，判断边是否满足level(u) +1= level(v)这一约束即可。
最大流模板【EdmondsKarp算法，简称EK算法，O(m^2n)】
(2011-05-26 23:28:50)
本文的目标群体是网络流的初学者，尤其是看了各种NB的教程也没看懂怎么求最大流的小盆友们。本文的目的是，解释基本的网络流模型，最基础的最大流求法，即bfs找增广路法，也就是EK法，全名是Edmond-Karp，其实我倒是觉得记一下算法的全名和来历可以不时的拿出来装一装。
我们就从这个零流开始考虑，假如有这么一条路，这条路从源点开始一直一段一段的连到了汇点，并且，这条路上的每一段都满足流量<容量，注意，是严格的<,而不是<=。那么，我们一定能找到这条路上的每一段的(容量-流量)的值当中的最小值delta。我们把这条路上每一段的流量都加上这个delta，一定可以保证这个流依然是可行流，这是显然的。
寻找增广路的时候我们可以简单的从源点开始做bfs，并不断修改这条路上的delta量，直到找到源点或者找不到增广路。
这里要先补充一点，在程序实现的时候，我们通常只是用一个c数组来记录容量，而不记录流量，当流量+1的时候，我们可以通过容量-1来实现，以方便程序的实现。
Bfs过程的半伪代码：下面另给一个C++版的模板
int BFS()
{
}
但事实上并没有这么简单，上面所说的增广路还不完整，比如说下面这个网络流模型。
我们第一次找到了1-2-3-4这条增广路，这条路上的delta值显然是1。于是我们修改后得到了下面这个流。（图中的数字是容量）
这时候(1,2)和(3,4)边上的流量都等于容量了，我们再也找不到其他的增广路了，当前的流量是1。
但这个答案明显不是最大流，因为我们可以同时走1-2-4和1-3-4，这样可以得到流量为2的流。
那么我们刚刚的算法问题在哪里呢？问题就在于我们没有给程序一个”后悔”的机会，应该有一个不走(2-3-4)而改走(2-4)的机制。那么如何解决这个问题呢？回溯搜索吗？那么我们的效率就上升到指数级了。
而这个算法神奇的利用了一个叫做反向边的概念来解决这个问题。即每条边(I,j)都有一条反向边(j,i)，反向边也同样有它的容量。
我们直接来看它是如何解决的：
在第一次找到增广路之后，在把路上每一段的容量减少delta的同时，也把每一段上的反方向的容量增加delta。即在Dec(c[x,y],delta)的同时，inc(c[y,x],delta)
我们来看刚才的例子，在找到1-2-3-4这条增广路之后，把容量修改成如下
这时再找增广路的时候，就会找到1-3-2-4这条可增广量，即delta值为1的可增广路。将这条路增广之后，得到了最大流2。
那么，这么做为什么会是对的呢？我来通俗的解释一下吧。
事实上，当我们第二次的增广路走3-2这条反向边的时候，就相当于把2-3这条正向边已经是用了的流量给”退”了回去，不走2-3这条路，而改走从2点出发的其他的路也就是2-4。（有人问如果这里没有2-4怎么办，这时假如没有2-4这条路的话，最终这条增广路也不会存在，因为他根本不能走到汇点）同时本来在3-4上的流量由1-3-4这条路来”接管”。而最终2-3这条路正向流量1，反向流量1，等于没有流量。
这就是这个算法的精华部分，利用反向边，使程序有了一个后悔和改正的机会。而这个算法和我刚才给出的代码相比只多了一句话而已。
#include<iostream>
#include<queue>
using namespace std;
const int maxn=205;
const int inf=0x7fffffff;
int r[maxn][maxn]; //残留网络，初始化为原图
bool visit[maxn];
int pre[maxn];
int m,n;
bool bfs(int s,int t)
{
}
int EdmondsKarp(int s,int t)
{
}
int main()
{
}
Dinic算法
Dinic算法的思想也是分阶段地在层次图中增广。
它与最短路径增值算法不同之处是：在Dinic算法中，我们用一个dfs过程代替多次bfs来寻找阻塞流。下面给出其算法步骤：
算法流程
增广过程图解
伪代码描述
在程序里，p表示找到的增广路径，p.top为路径中的最后一个顶点。一开始，p中只有源点。
整个While循环分为2个操作。如果p的最后一个顶点为汇点，也就是说找到了增广路，那么对p增广，注意到增广后一定有一条或多条p中的边被删除了。这时，我们使增广路径后退至p中从源点可到达的最后一个顶点。
如果p的最后一个顶点不为汇点，那么观察最后那个的顶点u 。若在层次图中存在从u连出的一条边，比如(u,v)，我们就将顶点v放入路径p中，继续dfs遍历；否则，点u对之后的dfs遍历就没有用了，我们将点u以及层次图中连到u的所有边删除，并且在p中后退一个点。
Dfs过程将会不断重复这2个操作，直到从源点连出的边全部被删除为止。
/*****以上来自<<浅谈基于分层思想的网络流算法>> 王欣*****/
模板
- /* filename :network_flow_Dinic.cpp
- * author :AntiheroChen
- * Description :It's a Dinic solution for the network flow prblem.
- * Complexity :O(V^2*E) always below this.
- * Version :1.00
- * History :
- * 1)2012/02/29 first release.
- */
- #include <iostream>
- #include <cstdio>
- #include <cstring>
- #include <cstdlib>
- using namespace std;
- const int maxn=1000+5, bign=1000000000;
- int M, n, m, source, sink, c[maxn][maxn], cnt[maxn];
- /* The arc of the flow network.*/
- struct Pool
- {
- int next, t, c;
- } edge[maxn*maxn<<1];
- /* The point of the flow network.*/
- struct Point
- {
- int son, cur, pre, lim, d;
- } a[maxn];
- /* Prepare for the algorithm.*/
- void initialize()
- {
- M=1;
- memset(c, 0, sizeof (c));
- memset(a, 0, sizeof (a));
- memset(cnt, 0, sizeof (cnt));
- }
- /* Add an arc to the flow network.*/
- void add(int x, int y, int z)
- {
- edge[++M].t=y;
- edge[M].c=z;
- edge[M].next=a[x].son;//相当于pool的head数组
- a[x].son=M;
- }
- /* Read the data and make it the right format.*/
- void input()
- {
- scanf("%*s%*d%d%d%d%d", &n, &m, &source, &sink);
- initialize();
- int x, y, z;
- while (m--)
- scanf("%d%d%d", &x, &y, &z), c[x][y]+=z;
- for (int i=0; i<n; i++)
- for (int j=0; j<n; j++)
- if (c[i][j])add(i, j, c[i][j]), add(j, i, c[j][i]), c[j][i]=0;
- }
- int que[maxn], fi, la;
- bool vis[maxn];
- /* Build the hierarchical graph for the algorithm*/
- bool build()
- {
- memset(vis, 0, sizeof (vis));
- que[fi=la=0]=sink;//reverse
- a[sink].d=0, a[sink].cur=a[sink].son, vis[sink]=true;
- while (fi<=la)
- {
- int v=que[fi++];
- for (int now=a[v].son, u; u=edge[now].t, now; now=edge[now].next)
- if (edge[now^1].c&&!vis[u])//BFS来分层,这里和EK相同
- {//倒着BFS的话,当然引用的还是对侧边,即正向边
- a[u].d=a[v].d+1;//越向前标号渐大
- a[u].cur=a[u].son;//cur指向头
- vis[u]=true;//已遍历
- que[++la]=u;//入队
- }
- if (vis[source])return true;//层次图向前已经扩展到原点
- }
- return false;
- }
- /*Use the Dinic algorithm to calculate the max flow.*/
- int MaxFlow()
- {
- int u, v, now, ret=0;
- while (build())
- {
- a[u=source].lim=bign;
- while (true)
- {
- for (now=a[u].cur; v=edge[now].t, now; now=edge[now].next)//cur优化
- if (edge[now].c&&a[u].d==a[v].d+1)break;//找到了一个子节点属于层次图
- if (now)
- {
- a[u].cur=edge[now].next;//下一次从这一条边的下一条边开始dfs
- a[v].pre=now;//指向v的边的指针
- a[v].lim=min(a[u].lim, edge[now].c);///更新到此处为止流的上限
- if ((u=v)==sink)//如果已经找到了一条增广路(走到了尽头)
- ///注意这个地方借判断语句, 将u下移, 便于判断为否的时候回到上面进入下一层!
- {//进行增广
- do
- {
- edge[a[u].pre].c-=a[sink].lim;
- edge[a[u].pre^1].c+=a[sink].lim;//这两句和Edmonds-Karp是一样的,增广
- u=edge[a[u].pre^1].t;//找前驱~!
- } while (u!=source);
- ret+=a[sink].lim;//增广完毕之后累加新找到的流
- }//否则(没走到尽头)继续向下DFS
- }
- else//没有子节点属于层次图
- {
- if (u==source)break;//已经退到了源,则已找到最大流,算法结束
- a[u].cur=now;//=0,此节点被废弃,子代亦然
- u=edge[a[u].pre^1].t;//根据反向边找到前驱~!
- }
- }
- }
- return ret;
- }
- int main()
- {
- int total;
- scanf("%d", &total);
- while (total--)
- {
- input();
- printf("%d\n", MaxFlow());
- }
- return 0;
- }
扫一扫
907
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
