对最大流算法Ford_Fulkerson的研究与理解

最新推荐文章于 2024-08-24 22:01:16 发布

weixin_34358365

最新推荐文章于 2024-08-24 22:01:16 发布

阅读量101

点赞数

文章标签： java matlab

本文链接：https://blog.csdn.net/weixin_34358365/article/details/85067666

版权

自己学习《图论》的基础算法，终于走到最大流的地盘了呵呵……我可是足足整了三天啊！！！

开始看ppt，讲述Ford_Fulkerson,尽管这个算法已经被更加优秀的 Edmonds-Karp算法所取代。我研究这个算法的目的其实在于 Edmonds-Karp算法,没办法，谁叫 Edmonds-Karp算法是由Ford_Fulkerson改进过来的呢！

把ppt看懂过后就自己上代码了。结果真的是让人崩溃：有向图，流竟然可以回退！意味着有向图必须用无向图的思路来考虑！

我自己写代码，优先考虑的是DFS。因为我觉得既然是从起点到汇点。DFS比较快嘛！我傻糊乎乎的照搬ppt上面的实现过程，把边提取出来，用一个类记录边的信息，然后用DFS去搜索，边搜边改。导致的结果是我连续改版了8次，一步步跟踪调试，当然注定是失败的！尽管最后都没成功，却让我一点一点清晰地理解了这个算法的实现过程！最后决定研究别人的代码了，不管三七二十一，先把代码贴出来吧！希望不会有盗用代码之嫌！

package com.xh.Ford_Fulkerson;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
/*
* 6 10 // 6 nodes, 10 edges
0 1 16 // capacity from 0 to 1 is 16
0 2 13 // capacity from 0 to 2 is 13
1 2 10 // capacity from 1 to 2 is 10
2 1 4 // capacity from 2 to 1 is 4
3 2 9 // capacity from 3 to 2 is 9
1 3 12 // capacity from 1 to 3 is 12
2 4 14 // capacity from 2 to 4 is 14
4 3 7 // capacity from 4 to 3 is 7
3 5 20 // capacity from 3 to 5 is 20
4 5 4 // capacity from 4 to 5 is 4
*/
public class Ford_Fulkerson09 {
private int capacity[][];
private int flow[][];
private boolean visited[];
private int pre[];//通过pre记录了路径
private int nodes;
static int count=0;
static int[][] map = { { 0, 2, 9, 3, 0 },// 三条边
{ 0, 0, 7, 0, 8 },// 两条边
{ 0, 6, 0, 4, 0 },// 两条边
{ 0, 0, 0, 0, 5 },// 一条边
{ 0, 0, 0, 0, 0 } //
};
public Ford_Fulkerson09(int[][] capacity, int nodes) {
this.capacity = capacity;
this.nodes = nodes;
this.flow = new int[nodes][nodes];
this.pre = new int[nodes];
this.visited = new boolean[nodes];
}
public int maxFlow(int src, int des) {
int maxFlow = 0;
for (int i = 0; i < nodes; i++)
for (int j = 0; j < nodes; j++)
flow[i][j] = 0;
while (true)// find a augment path
{
for (int i = 0; i < nodes; i++) {
visited[i] = false;
}
pre[src] = -1;
if (!BFS(src, des)) {// the BFS
System.out.println("break::::"+count);
break;
}
/*
* DFS(src,des);//DFS if(!visited[des]) break;
*/
int increment = Integer.MAX_VALUE;
System.out.println("path:" +(count++));
for (int i = des; pre[i] >= src; i = pre[i]) {
// find the min flow of the path
increment = Math.min(increment, capacity[pre[i]][i]
- flow[pre[i]][i]);
System.out.print(i+",");
}
System.out.print(0+",");
System.out.println();
// update the flow
//对记录的路径的处理从终点开始，到起点这里的处理是很巧的
for (int i = des; pre[i] >= src; i = pre[i]) {
flow[pre[i]][i] += increment;
flow[i][pre[i]] -= increment;//由于需要考虑到退回边，所以这里需要减少
/*不能不惊叹于这种处理本来我们的流是没有考虑负值的
* 而且的话，向前流的回退流需要两种不同的处理，而这里作者直接让回退流为负
* 这样的话，在bfs访问的过程中就不需要考虑两个点边的方向，这样就可以当作无
* 向图的来处理了*/
}
// increase the maxFow with the increment
System.out.println("==============flow==================");
for (int i = 0; i < flow.length; i++) {
for (int j = 0; j < flow.length; j++) {
System.out.print(flow[i][j]+" ");
}
System.out.println();
}
System.out.println("increment======="+increment+"============");
maxFlow += increment;
}
return maxFlow;
}
private boolean BFS(int src, int des) {
Queue<Integer> queue = new LinkedList<Integer>();
queue.add(src);
visited[src] = true;
System.out.print(queue.peek()+",");
while (!queue.isEmpty()) {
int node = queue.poll();
for (int i = 0; i < nodes; i++) {
if (!visited[i] && (capacity[node][i] - flow[node][i] > 0)) {// 只要满足条件的点都加进去，而不会考虑两个点的边是正向边还是回退边
/*
* capacity[node][i] - flow[node][i] > 0
* 如果刚开始，回退边的flow是0，capacity也是0，不会被选择
* 但是回退边的flow会被设为负值，所以后来遇到回退边的时候，回退边就会被考虑进来了尽管capacity为0
*/
queue.add(i);
visited[i] = true;
pre[i] = node;// record the augment path
System.out.print(i+",");
}
}
}
System.out.println("======================pre"+count+"================");
for (int i = 0; i < pre.length; i++) {
System.out.print(pre[i]+",");
}
System.out.println();
return visited[des];
}
public static void main(String[] args) {
int nodes;
nodes = map[0].length;
int[][] capacity = new int[nodes][nodes];
for (int i = 0; i < nodes; i++) {
for (int j = 0; j < nodes; j++) {
if (map[i][j] != 0) {
capacity[i][j] = map[i][j];
}
}
}
Ford_Fulkerson09 maxFlow = new Ford_Fulkerson09(capacity, nodes);
System.out.println(maxFlow.maxFlow(0, nodes - 1));
}
}

由于代码中加入了打印输出，所以显得有点乱。如果研究，最好先把里面大量的输出去掉。原图如下

当然这个图用矩阵的方式来存储，其实由于开始看图论是看matlab的原因，习惯了矩阵。

这个程序的实现有以下几点我觉得是很值得赞赏的：

采用BFS搜索，只记录可以实现的路径。而且在对路径的处理

// update the flow
   //对记录的路径的处理从终点开始，到起点这里的处理是很巧的
   for (int i = des; pre[i] >= src; i = pre[i]) {
    flow[pre[i]][i] += increment;
    flow[i][pre[i]] -= increment;//由于需要考虑到退回边，所以这里需要减少
    /*不能不惊叹于这种处理   本来我们的流是没有考虑负值的
     * 而且的话，向前流的回退流需要两种不同的处理，而这里作者直接让回退流为负
     * 这样的话，在bfs访问的过程中就不需要考虑两个点边的方向，这样就可以当作无
     * 向图的来处理了*/
   }

然后就是为流量的变化建立了一个跟capacity一样大小的矩阵。当然空间开销有点大。

再就是bfs实现的细节。当时我自己的考虑纠结在有向图边方向的问题上了。他这里直接绕过去了……给人的感觉好像根本就不用考虑边的方向，甚至都不用考虑边！只要满足：流量<容量这个条件就够了！而其实，这个条件包含了以下的隐藏的条件：比如：两点一定会有边的，因为有边才有流量。如果是回退流，那当然其容量为0，但只要流量为负就ok了！

当然，我觉得在BFS搜索的过程中，其实做了许多无用的搜索。差不多是每个点必须搜索到，如果汇点搜索不到的话程序就可以结束了呵呵！

weixin_34358365

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
对最大流算法Ford_Fulkerson的研究与理解

自己学习《图论》的基础算法，终于走到最大流的地盘了呵呵……我可是足足整了三天啊！！！开始看ppt，讲述Ford_Fulkerson,尽管这个算法已经被更加优秀的 Edmonds-Karp算法所取代。我研究这个算法的目的其实在于 Edmonds-Karp算法,没办法，谁叫 Edmonds-Karp算法是由Ford_Fulkerson改进过来的呢！把ppt看懂过后就自己上代码...
复制链接

扫一扫