网络流 - Edmond-Karp 小讲【理解 + 例题】更新 ing...

最新推荐文章于 2024-02-07 08:43:41 发布

Joursion

最新推荐文章于 2024-02-07 08:43:41 发布

阅读量1k

点赞数

分类专栏： ACM - 学习笔记文章标签： bfs poj 网络流

本文链接：https://blog.csdn.net/xi__long/article/details/39613953

版权

ACM - 学习笔记专栏收录该内容

40 篇文章 0 订阅

订阅专栏

希望每天晚上在机房，可以去不断地提升自己吧，也真的希望，可以像学长、六大神那样牛！

概念：

增广路：从源点到汇点的一条简单路，如果路上的每条边（u，v）的可改进量均大于0，则称这条路为一条增广路。

可行弧：在EK算法中指可从u到v增加流量（也就是容量不为0）。

汇点：只进不出的点。

源点：只出不进的点，在建图的时候，可以先虚拟出一个源点，不管题目中有几个。

思路：

EK算法就是通过bfs ，找出一条可以最短的可行路，再去不断地找增广路，每次都对其进行增广，直到源点和汇点不连通，也就是找不到增广路为止。当找不到增广路的时候，当前的流量就是最大流。在程序实现过程中，通过减少容量的方法来限制可增数的大小。

另外一点需要注意的是，对反向弧的作用和理解，实在理解不了的话，其它部分一定要去理解，这里贴一下其它巨巨的讲解。

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

下面这个网络流模型：（delta 即可增加的流量）

我们第一次找到了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。

我们直接来看它是如何解决的：

我们来看刚才的例子，在找到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，等于没有流量。

    这就是这个算法的精华部分，利用反向边，使程序有了一个后悔和改正的机会。

--------------------------------------------------------------------------------------------------------------------------------------------------

例题：

1. POJ 1273 Drainage Ditches 链接： http://poj.org/problem?id=1273

这道题可以说是一道入门的网络流的题目，今天下午到现在，才弄明白，在群里问了好久，也没人理我-。- 注意一下细节和思路，不会多多去模拟一下，然后再去找几道题目做一做、

#include <iostream>
#include <queue>
#include <string.h>
#include <cstdio>
using namespace std;
const int maxn = 250;
const int inf = 0x7fffffff;

int r[maxn][maxn]; // 构造初始的网络
int pre[maxn];
bool vis[maxn];
int n, m;

// 判断能否形成一条可行路
bool bfs(int s, int t)
{
	int p;
	queue<int> q;
	memset(pre, -1, sizeof(pre));
	memset(vis, 0, sizeof(vis));
	pre[s] = s;
	vis[s] = 1;
	q.push(s);
	while(!q.empty())
    {
        p = q.front();
        q.pop();
        ///printf("%d     lalala\n", p);  我在模拟的时候，便于理解 有三个斜杠的、
        for(int i = 1; i <= n; i ++)
        {
            if(r[p][i] > 0 && !vis[i])  // 我在这里卡了超级久、、
            {
                pre[i] = p;
                vis[i] = 1;
                if(i == t)
                    return true; //如果已经到达汇点，说明存在增广路径返回true
                q.push(i);  //如果没有连接到汇点,一直到遍历结束
            }
        }
        ///printf("本次查找还没结束\n");
    }
    return false;
}

int EK(int s, int t)
{
    int flow = 0;
    int d;
    while(bfs(s, t))
    {
        d = inf;
        for(int i = t; i != s; i = pre[i])
        {
            if(d >= r[pre[i]][i])
                d = r[pre[i]][i];  //找可行路中的最小容量
        }
        for(int i = t; i != s; i = pre[i])
        {
            r[pre[i]][i] -= d;  
            r[i][pre[i]] += d; // 反向弧的处理，我觉得如果现在没弄懂，可以先放着
        }
        flow += d;
    }
    return flow;
}

int main()
{
    while(~scanf("%d%d",&m,&n))
    {
        int u, v, w;
        memset(r, 0, sizeof(r));
        for(int i = 0; i < m; i ++)
        {
            scanf("%d%d%d", &u, &v, &w);
            r[u][v] += w;
        }
        printf("%d\n", EK(1, n));
    }
    return 0;
}