图论4——探索网络流的足迹:Dinic算法

1. 网络流:定义与简析

1.1 网络流是什么?

网络流是一种“类比水流的解决问题方法,与线性规划密切相关”(语出百度百科)。

其实,在信息学竞赛中,简单的网络流并不需要太高深的数学知识。

首先我们需要知道一些名词是什么意思:

  • 点(\(node\))。就是一个节点。点集通常用\(V\)表示。其中,有一个源点\(s\)和一个汇点\(t\),所有的流都从源点\(s\)出发,经过一些边之后到达汇点\(t\)。
  • 边(\(edge\))。这个东西和大家在其他图论知识中所用到的差不多,用于连接两个点。边集通常用\(E\)表示。图\(G(V,E)\)表示由点集\(V\)和边集\(E\)组成的图\(G\)。在接下来讲到的有关网络流的问题中,边都是有向的。
  • 容量(\(capacity\),简称\(cap\))。对于每一条边,我们都有一个容量,表示这条边最多能经过的流。

1.2 问题简述

显然,根据如上定义,到达汇点\(t\)的流是有限的。网络流问题(NetWork Flow Problem)就是如何合理安排一种方式,使得从源点\(s\)到汇点\(t\)的流最多。

感觉枯燥吗?其实我们可以这么感性的理解。

你的家里有\(10^{10^{10^{10}}}\)箱苹果,然后你要通过一些高速公路把他们运到你的亲戚家。由于某些限制,连接\(u\)和\(v\)的高速公路\((u,v)\)一天只能允许载有不超过\(cap(u,v)\)的卡车通过。显然,一天之内,能运送的苹果数量是有限的,因为这些高速路的限制只能让你运送其中的一些。那么如何安排这些苹果的运送方式,使得一天之内最后运到你亲戚家的苹果最多?

显然,即使你把所有的\(10^{10^{10^{10}}}\)箱苹果都运送给你的亲戚,但是最后绝大多数都会在高速路收费站被拦下来——超载(并且最后被工作人员吃掉)。最多能够送给亲戚的苹果数(即在最优方案下到达\(t\)的流)就称之为最大流


2. 网络流:尝试与解决

2.1 贪心分析

A:这个问题不是可以贪心一遍然后\(O(n+m)\)就解决了吗?

B:怎么贪心?你做一遍试一下啊!

A:就是每一次都尽量多地往汇点送,如果下一条边不能再运送这么多的容量就分到其他条边不就好了吗?

B:(随手一个图)

A:然后我开始详细讲我的贪心算法了。

\(\quad\)首先我们从\(s\to 2\to 5\to t\)运送\(3\)箱苹果,从\(s\to 2\to 6\to t\)运送\(1\)箱苹果;

\(\quad\)然后……\(s\to 3\to 5\to t\)就不行了……

\(\quad\)最后\(s\to 4\to 5\to t\)还有\(7\)箱。这样合计\(11\)箱。(强行掩饰)那你有更好地解法吗?

B:显然有。如果你没有这么贪心,从\(s\to 2\to 5\to t\)只运送\(2\)箱苹果,剩下两箱从\(s\to 2\to 6\to t\)走,这样\(s\to 3\to 5\to t\)还可以运一箱。最后\(s\to 4\to 5\to t\)还有\(7\)箱。合计\(2+2+1+7=12\)箱。

通过这段对话,我们发现,由于输入顺序未知,贪心很容易产生问题(尽管在这张图中你有一半的可能得到正确答案,而在数据量大的时候,不出错的概率很小)。所以我们考虑正确的解法。

2.2 朴素算法

在学习朴素算法之前,我们需要补充一个网络流中常用到的定理。

如果设\(f(u,v)\)为实际从这条边上走过的流量大小,则:

  1. 容量原则:\(f(u,v)\le cap(u,v)\).这个是显然的,你不可能实际流量比限制容量还大(否则你会因为超载被警察叔叔开罚单)。
  2. 反对称性:\(f(u,v)=-f(v,u)\).这个也是显然的,你送给亲戚\(10\)个苹果不就相当于你从亲戚那里拿到了\(-10\)个苹果吗?(尽管听上去总感觉好像不太正常)
  3. 流量守恒:当\(u\ne s,t\)时,如果规定边\((u,v)\)和\((v,u)\)都不存在时\(f(u,v)=f(v,u)=0\)的话,那么\(\displaystyle\sum^{v\in V}_ {v} f(u,v) =0\)。这个并不是那么好理解,简单来说,因为从\(s\)点流出的流最终都汇入\(t\),所以中间所有边都不会有剩下的流没有出去。只有\(s\)和\(t\)会“制造”和“接受”流量。(你不想让高速路的工作人员把你的苹果吃掉,所以一定选取刚好的苹果给亲戚;自然亲戚会全部收到,所以高速路的工作人员没有办法拦下你的苹果)。

有了这三条定理,我们就开始讲朴素算法。

我们首先给每一条边连上反向边。这条反向边的性质就像上面定理2“反对称性”中的反向边一样。

由于目前的网络流算法都基于增广路思想,我们还是要介绍一下增广路。

增广路思想

增广路定义:一条从源点到汇点的路径,使得路径上任意一条边的残量\(>0\)(注意是\(>\)而不是\(\ge\),这意味着这条边还可以分配流量),这条路径便称为增广路。

我们设\(g_{u,v}\)表示\((u,v)\)这条边上的残量,即剩余流量。

  1. 找到一条增广路,记这条路径上的边集为\(P\)。
  2. 记\(flow=\displaystyle\min_{(u,v)}^{(u,v)\in P} g_{u,v}\).
  3. 将这条路径上的每一条有向边\(u,v\)的残量\(g_{u,v}\)减去\(flow\),同时对于反向边\(v,u\)的残量加上\(flow\)。
  4. 重复上述过程,直到找不出增广路,此时我们就找到了最大流。

为什么反向边要加上\(flow\)呢?因为对于下面这个例子:

所以需要加上\(flow\)。

复杂度分析

这个复杂度是\(O(nm^2)\),而且往往不会少跑很多,所以只能用过\(n,m\le 300\)的数据。


Dinic算法

我们发现朴素算法有的时候会跑得特别特别的慢,因为增广路径查找得很不优秀。比如:

如果程序很不友好的在\((3,4)\)和\((4,3)\)中来回跑,那么显然复杂度会高到离谱。所以在Dinic中,我们引入分层图的概念。

分层图

对于每一个点,我们根据从源点\(s\)开始的bfs序,为每一个点分配一个深度\(dep_i\),然后通过不断dfs寻找增广路,每一次dfs当且仅当\(dep_v=dep_u+1\)是才从\(u\)到\(v\),这样上面的情况就避免了。

复杂度估计

那么Dinic的复杂度是多少呢?答案是\(O(n^2m)\)。事实上这只是最差情况下的估计,实际上远没有这么大,对于\(n,m\le 10^5\)的数据往往是可以轻松过的。


代码:

下面是代码。其中\(d\)数组即\(dep_i\),每次通过bfs构造层次图,然后dfs增广。

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
const int MAXN=100010;
const int INF=0x3f3f3f3f;

class Dinic
{
    private:
        struct edge
        {
            int from,to,cap,flow;
        };
        vector<edge>e;
        vector<int>f[MAXN];
        queue<int>q;
        bool vis[MAXN];
        int d[MAXN];
        int cur[MAXN];   

        bool bfs()
        {
            memset(vis,0,sizeof(vis));
            while(!q.empty())
                q.pop();
            q.push(s);d[s]=0;vis[s]=1;
            while(!q.empty())
            {
                int x=q.front();q.pop();
                for(int i=0;i<f[x].size();i++)
                {
                    edge &y=e[f[x][i]];
                    if(!vis[y.to]&&y.flow<y.cap)
                    {
                        vis[y.to]=1;
                        d[y.to]=d[x]+1;
                        q.push(y.to);
                    }
                }
            }
            return vis[t];
        }
        int dfs(int x,int a)
        {
            if(x==t)
                return a;
            if(a==0)
                return 0;
            int flow=0,r;  

            for(int &i=cur[x];i<f[x].size();i++)
            {
                edge &y=e[f[x][i]];
                if(d[x]+1==d[y.to]&&(r=dfs(y.to,min(a,y.cap-y.flow)))>0)
                {
                    y.flow+=r;
                    e[f[x][i]^1].flow-=r;
                    flow+=r;
                    a-=r;
                    if(a==0)
                        break;
                }
            }
            return flow;
        }

    public:
        int n,m,s,t;
        void adde(int u,int v,int cap)
        {
            e.push_back((edge){u,v,cap,0});
            e.push_back((edge){v,u,0,0});
            this->m=e.size();
            f[u].push_back(m-2);
            f[v].push_back(m-1);
        }
        int maxflow()
        {
            int res=0;
            while(bfs())
            {
                memset(cur,0,sizeof(cur));
                res+=dfs(s,INF);
            }
            return res;
        }
};

如果需要使用这个模板,只需要输入\(n,s,t\),而\(m\)将根据加边次数计算。

这个模板的技巧在于,存反向边的时候利用了位运算\(xor\)的技巧:如果边的编号从\(0\)计数,那么相邻的边编号就是\(2x,2x+1\),在计算机中\(2x\ xor\ 1=2x+1\),而\((2x+1)\ xor\ 1=2x\)。这样可以很方便的读取反向边。

原文地址:https://www.cnblogs.com/frankchenfu/p/8505207.html

时间: 2024-10-11 21:20:41

图论4——探索网络流的足迹:Dinic算法的相关文章

网络流最大流——dinic算法

前言 网络流问题是一个很深奥的问题,对应也有许多很优秀的算法.但是本文只会讲述dinic算法 最近写了好多网络流的题目,想想看还是写一篇来总结一下网络流和dinic算法以免以后自己忘了... 网络流问题简述 一个很普遍的例子就是--你家和自来水厂之间有许多中转站,中转站又由一些水管连接着.我们假设自来水厂的供水是无限的,并且中转站内能存储的水量也是无限的,但是管道有宽又窄,很显然管道内的流量必须小于等于管道的承载范围(否则管道就被撑爆了),那么问题就是要你求出你家最多能收到多大流量的水. emm

poj1273 网络流入门题 dinic算法解决,可作模板使用

Drainage Ditches Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 62078   Accepted: 23845 Description Every time it rains on Farmer John's fields, a pond forms over Bessie's favorite clover patch. This means that the clover is covered by

hiho一下 第119周 #1398 : 网络流五&#183;最大权闭合子图 【最小割-最大流--Ford-Fulkerson 与 Dinic 算法】

#1398 : 网络流五·最大权闭合子图 时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 周末,小Hi和小Ho所在的班级决定举行一些班级建设活动. 根据周内的调查结果,小Hi和小Ho一共列出了N项不同的活动(编号1..N),第i项活动能够产生a[i]的活跃值. 班级一共有M名学生(编号1..M),邀请编号为i的同学来参加班级建设活动需要消耗b[i]的活跃值. 每项活动都需要某些学生在场才能够进行,若其中有任意一个学生没有被邀请,这项活动就没有办法进行. 班级建设的活

[知识点]网络流之Dinic算法

// 此博文为迁移而来,写于2014年2月6日,不代表本人现在的观点与看法.原始地址:http://blog.sina.com.cn/s/blog_6022c4720102vrg4.html 今天我们来谈谈网络流之Dinic算法.这种算法相比Edmond-Karp算法,更加快速,更加常用.还记得EK吗?每次为了防止流量堵塞,必须进行多次BFS/DFS,非常费时间.而Dinic大叔非常机智的发明了Dinic算法,让这个问题得以解决. Dinic的核心内容是:反复进行BFS绘制出层次图,和DFS进行

POJ 2135 Farm Tour (dinic算法,网络流)

构图方法: 注意题目中的边为无向边.新建源点s 和 汇点t 每两条道路连一条容量为1,费用为w的边.s到1连一条容量为1,费用为0 的边,n到 t 连一条容量为1,费用为0 的边,求最大流. #include <iostream> #include <cstring> #include <cstdlib> #include <cstdio> #include <algorithm> #include <queue> #include

hdu 3572 Task Schedule(网络流 dinic算法)

Task Schedule Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 3412    Accepted Submission(s): 1197 Problem Description Our geometry princess XMM has stoped her study in computational geometry t

zoj 3229 dinic算法的非递归实现以及有上下界的有源汇的网络流的最大流的求解

Shoot the Bullet Time Limit: 2 Seconds      Memory Limit: 32768 KB      Special Judge Gensokyo is a world which exists quietly beside ours, separated by a mystical border. It is a utopia where humans and other beings such as fairies, youkai(phantoms)

POJ 1273 Drainage Ditches(网络流dinic算法模板)

POJ 1273给出M条边,N个点,求源点1到汇点N的最大流量. 本文主要就是附上dinic的模板,供以后参考. #include <iostream> #include <stdio.h> #include <algorithm> #include <queue> #include <string.h> /* POJ 1273 dinic算法模板 边是有向的,而且存在重边,且这里重边不是取MAX,而是累加和 */ using namespace

hdu-3572 Task Schedule---最大流判断满流+dinic算法

题目链接: http://acm.hdu.edu.cn/showproblem.php?pid=3572 题目大意: 给N个任务,M台机器.每个任务有最早才能开始做的时间S,deadline E,和持续工作的时间P.每个任务可以分段进行,但是在同一时刻,一台机器最多只能执行一个任务. 问存不存在可行的工作时间. 解题思路: 由于时间<=500且每个任务都能断断续续的执行,那么我们把每一天时间作为一个节点来用网络流解决该题. 建图: 源点s(编号0), 时间1-500天编号为1到500, N个任务