网络流初步---最大流(EK算法+Dinic算法）

最新推荐文章于 2022-08-21 23:34:26 发布
最新推荐文章于 2022-08-21 23:34:26 发布
阅读量324 收藏 2
点赞数
分类专栏： 网络流 文章标签： 算法 网络 bfs 数据结构 dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45677913/article/details/107406085
版权

概念： 最大流问题，是网络流理论研究的一个基本问题，目的是求网络中的可行流，使得从源点出发到达最终汇点所得的最大流量最大。

首先是比较简单的EK算法：
EK算法主要核心是不断进行bfs求增广路，所谓增广路就是从源点出发到达汇点的一条流量不为0的路径，该条路径可以为汇点带来不小于0的流量，然后对求得的增广路径权值进行修改，再进行下一条增广路径的bfs，直至没有增广路为止；

BFS代码如下：

int bfs(){
    for(int i=1;i<=n;i++)vis[i]=0;
    vis[s]=1;dis[s]=inf;//dis数组记录从s到达i时的最小流量
    queue<int>q;
    q.push(s);
    while(!q.empty()){
        int x=q.front();q.pop();
        for(int i=head[x];i;i=e[i].nxt){
            int u=e[i].to;
            if(vis[u]||e[i].val==0)continue;
            vis[u]=1;
            pre[u]=i;//记录是从那一条路径来的
            q.push(u);
            dis[u]=min(dis[x],e[i].val);
            if(u==t)return 1;//找到增广路返回，此时dis[t]就是本次增广路带来的流量
        }
    }
    return 0;
}

接下来是更新增广路的路径权值：
这个时候需要对网络中的来的路径反向边添加本次增广路带来的流量，相当于给程序带来一次反悔的机会；
代码如下：

void update(){
    int x=t;
    while(x!=s){
        e[pre[x]].val-=dis[t];//增广路径上减去对应的流量
        e[pre[x]^1].val+=dis[t];//反向边加上对应的流量
        x=e[pre[x]^1].to;
    }
    ans+=dis[t];//累加最大流值
}

EK算法的完整代码如下：
P3376 【模板】网络最大流

#include<bits/stdc++.h>
#define LL long long
#define all(x) (x).begin(),(x).end()
#define le(x) ((int)(x).size())
#define pii pair<int,int>
#define PII pair<LL,LL>
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define db printf("Here!\n");
using namespace std;
const double eps=1e-8;
const double Pi=4.0*atan(1.0);
const LL inf=1e14+10;
const int N=2e3+10;
const int M=1e7+5;
const int mod=998244353;
//mt19937 rnd(time(0)),shuffle(a+1,a+1+n,rnd);
int n,m,k,t,len,op,x,y,s;
LL head[N],T=1,ans,dis[N],z;
int vis[N],ind[N][N],pre[N];
struct Edge{
    int nxt,to;
    LL val;
}e[N*100];
void add(int x,int y,LL z){
    e[++T].nxt=head[x];
    head[x]=T;
    e[T].to=y;
    e[T].val=z;
    e[++T].nxt=head[y];
    head[y]=T;
    e[T].to=x;
    e[T].val=0;
}
int bfs(){
    for(int i=1;i<=n;i++)vis[i]=0;
    vis[s]=1;dis[s]=inf;
    queue<int>q;
    q.push(s);
    while(!q.empty()){
        int x=q.front();q.pop();
        for(int i=head[x];i;i=e[i].nxt){
            int u=e[i].to;
            if(vis[u]||e[i].val==0)continue;
            vis[u]=1;
            pre[u]=i;
            q.push(u);
            dis[u]=min(dis[x],e[i].val);
            if(u==t)return 1;
        }
    }
    return 0;
}
void update(){
    int x=t;
    while(x!=s){
        e[pre[x]].val-=dis[t];
        e[pre[x]^1].val+=dis[t];
        x=e[pre[x]^1].to;
    }
    ans+=dis[t];
}
void DO(){
    scanf("%d%d%d%d",&n,&m,&s,&t);
    for(int i=1;i<=m;i++){
        scanf("%d%d%lld",&x,&y,&z);
        if(ind[x][y]){
            e[ind[x][y]].val+=z;
        }else {
            add(x,y,z);
            ind[x][y]=T-1;
        }
    }
    while(bfs())update();
    printf("%lld\n",ans);
}
int main(){
    //int o;scanf("%d",&o);
    //while(o--){
        DO();
    //}
    return 0;
}

EK算法的时间复杂度是O(nm^2)；
EK算法主要是因为每一次只能找到一条增广路，所以算法时间复杂度较高，但是对于稀疏来说，EK算法求解较为优秀；

对于一次性找到多条增广路来说，Dinic算法有着非常优秀的复杂度：
Dinic算法主要也是求增广路的过程，但是它利用残量网络中bfs建立分层图+dfs方式可以一次性找到多条增广路径，并且在回溯的过程中可以更新边权，再加上一些减枝和优化可以达到很好的时间复杂度，因此dinic算法相较于EK算法来说比较优秀，Dinic算法时间复杂度为O(n^2m)，在稠密图中有很大的优势。

Dinic算法代码如下：

#include<bits/stdc++.h>
#define LL long long
#define all(x) (x).begin(),(x).end()
#define le(x) ((int)(x).size())
#define pii pair<int,int>
#define PII pair<LL,LL>
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define db printf("Here!\n");
using namespace std;
const double eps=1e-8;
const double Pi=4.0*atan(1.0);
const LL inf=1e13+10;
const int N=2e3+10;
const int M=1e7+5;
const int mod=998244353;
//mt19937 rnd(time(0)),shuffle(a+1,a+1+n,rnd);
int n,m,k,t,len,op,x,y,s;
LL head[N],T=1,ans,z,dep[N],ind[N][N],now[N];
struct Edge{
    int nxt,to;
    LL val;
}e[N*100];
void add(int x,int y,LL z){
    e[++T].nxt=head[x];
    head[x]=T;
    e[T].to=y;
    e[T].val=z;
    e[++T].nxt=head[y];
    head[y]=T;
    e[T].to=x;
    e[T].val=0;
}
int bfs(){
    for(int i=1;i<=n;i++)dep[i]=0;
    dep[s]=1;now[s]=head[s];
    queue<int>q;
    q.push(s);
    while(!q.empty()){
        int x=q.front();q.pop();
        for(int i=head[x];i;i=e[i].nxt){
            int u=e[i].to;
            if(dep[u]||e[i].val<=0)continue;
            now[u]=head[u];//初始化now数组，初始所以边都是可以访问的
            dep[u]=dep[x]+1;//残量网络建立分层图
            q.push(u);
            if(u==t)return 1;
        }
    }
    return 0;
}
LL dfs(int u,LL flow){//flow记录到达u时剩余的流量
    if(u==t)return flow;//找到会点直接返回最后流量
    LL res=0,ret;
    for(int i=now[u];i&&flow;i=e[i].nxt){
        now[u]=i;//当前弧优化，已经遍历的边一定不会存在可行的增广路，因此可以去掉
        int v=e[i].to;
        if(dep[v]!=dep[u]+1||e[i].val<=0)continue;
        ret=dfs(v,min(flow,e[i].val));
        if(!ret)dep[v]=inf;//减枝，如果该顶点不能带来流量，标记不能访问即可
        res+=ret;//更新答案
        flow-=ret;
        e[i].val-=ret;
        e[i^1].val+=ret;
    }
    return res;
}
void DO(){
    scanf("%d%d%d%d",&n,&m,&s,&t);
    for(int i=1;i<=m;i++){
        scanf("%d%d%lld",&x,&y,&z);
        if(ind[x][y]){
            e[ind[x][y]].val+=z;
        }else {
            add(x,y,z);
            ind[x][y]=T-1;
        }
    }
    while(bfs())ans+=dfs(s,inf);
    printf("%lld\n",ans);
}
int main(){
    //int o;scanf("%d",&o);
    //while(o--){
        DO();
    //}
    return 0;
}

例题：
P1402 酒店之王
题意：保证一个人在自己喜欢的房间里吃自己喜欢的菜的最大人数是多少，一道菜和一个房间只能一个人使用；
解题思路：
首先对问题进行建模，因为我们要保证菜和房间都只能使用一次，因此我们需要建一个超级源点连向所有的菜，所有的房间都连向超级汇点，流量都是1，人在中间，这样就能保证菜和房间都只使用一次，为了保证人只能匹配一次，还要对每一个人建立一个虚点相连，最后跑一个最大流即可；

代码如下：

#include<bits/stdc++.h>
#define LL long long
#define all(x) (x).begin(),(x).end()
#define le(x) ((int)(x).size())
#define pii pair<int,int>
#define PII pair<LL,LL>
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define db printf("Here!\n");
using namespace std;
const double eps=1e-8;
const double Pi=4.0*atan(1.0);
const LL inf=2e9+10;
const int N=2e3+10;
const int M=1e7+5;
const int mod=998244353;
//mt19937 rnd(time(0)),shuffle(a+1,a+1+n,rnd);
int n,m,k,t,len,op,x,y,p,q,s;
int head[N],now[N],dep[N],T=1,ans,vis[N][N];
struct Edge{
    int to,nxt;
    LL val;
}e[N*100];
void add(int x,int y,int z){
    e[++T].nxt=head[x];
    head[x]=T;
    e[T].to=y;
    e[T].val=z;
    e[++T].nxt=head[y];
    head[y]=T;
    e[T].to=x;
    e[T].val=0;
}
int bfs(){
    for(int i=0;i<=t;i++)dep[i]=0;
    dep[s]=1;now[s]=head[s];
    queue<int>q;
    q.push(s);
    while(!q.empty()){
        int x=q.front();q.pop();
        for(int i=head[x];i;i=e[i].nxt){
            int u=e[i].to;
            if(dep[u]||e[i].val<=0)continue;
            dep[u]=dep[x]+1;
            now[u]=head[u];
            q.push(u);
            if(u==t)return 1;
        }
    }
    return 0;
}
LL dfs(int u,LL flow){
    if(u==t)return flow;
    LL res=0,ret;
    for(int i=now[u];i&&flow;i=e[i].nxt){
        now[u]=i;
        int v=e[i].to;
        if(dep[v]!=dep[u]+1||e[i].val<=0)continue;
        ret=dfs(v,min(flow,e[i].val));
        if(!ret)dep[v]=inf;
        res+=ret;
        flow-=ret;
        e[i].val-=ret;
        e[i^1].val+=ret;
    }
    return res;
}
void DO(){
    scanf("%d%d%d",&n,&p,&q);
    s=0,t=n*2+q+p+1;
    for(int i=1;i<=p;i++)add(0,i,1);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=p;j++){
            scanf("%d",&x);
            if(x)add(j,i+p,1);
        }
    }
    for(int i=1;i<=n;i++)add(p+i,p+i+n,1);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=q;j++){
            scanf("%d",&x);
            if(x)add(i+p+n,n*2+p+j,1);
        }
    }
    for(int i=1;i<=q;i++)add(i+n*2+p,t,1);
    while(bfs())ans+=dfs(0,inf);
    printf("%d\n",ans);
}
int main(){
    //int o;scanf("%d",&o);
    //while(o--){
        DO();
    //}
    return 0;
}
SuperDeyang
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最大网络流Dinic算法
09-01
用于计算最大网络流的经典的Dinic算法，代码自带例子，边权支持double类型。
最大网络流 EK 算法
weixin_30883777的博客
05-27 64
网络流是什么类型的问题，看一道题目你就知道了点击打开链接。 默认具备图论的基本知识，网络流概念比较多，先看看书熟悉一下那些概念。比较好！一个寄出的网络最大流。EK算法写的。 这是一幅网络，求S ------> T 点的最大网络流。 这是初始状态。{a,b} a 代表该边的最大流量，b代表实际的流量。 一开始，实际流量为0；下面是代码。 &l...
求最大流的两种算法 EK算法和dinic算法
qq_40938077的博客
05-21 2800
我们接下来讲的都是按照这个图来讲的   EK算法 算法思想，基本流程： 通过广搜函数寻找增广路，然后函数返回的是找到的增广路中权值最小的值，如果找不到增广路，返回0。然后运用广搜函数返回的值更新邻接矩阵中的值。每次都把广搜函数返回的值累加，直到图中不存在增广路为止，累加的结果就是最大流。 代码如下： #include&lt;bits/stdc++.h&gt; #define MA...
网络最大流（网络流初步）
日居月诸的博客
11-04 110
文章目录网络流模板算法1：dinic 网络流模板 例题：LGOJ P3376 【模板】网络最大流 算法1：dinic //IO etc. #include<cstring> const int MAXN = 1e4 + 5; const int MAXM = 1e5 + 5; const int INF = 0x7f7f7f7f; int N, M, S, T; struct Edge...
网络流入门，EK算法和Dinic算法求最大流
NGUP_LEE的博客
03-29 620
文章目录1.什么是网络流1.1网络流的相关定义1.2相关性质1.3求最大流的问题模型2.如何求最大流3.关于反向边4.EK算法和Dinic算法4.1EK（Edmonds-Karp）算法4.2Dinic算法 1.什么是网络流 网络流（英语：Network flow）是指在一个每条边都有容量（Capacity）的有向图分配流，使一条边的流量不会超过它的容量。通常在运筹学中，有向图称为网络。顶点称为节...
网络流：最大流EK算法
STDEN的博客
10-10 157
Mirko works on a pig farm that consists of M locked pig-houses and Mirko can’t unlock any pighouse because he doesn’t have the keys. Customers come to the farm one after another. Each of them has keys to some pig-houses and wants to buy a certain number of
网络流最大流Dinic算法代码
10-16
最大流的Dinic算法，时间复杂度O(EV^2),代码简单而高效
图论- 网络流- 最大流- Dinic 算法.rar
09-16
图论- 网络流- 最大流- Dinic 算法.rar
C/C++，图算法-Dinic最大流量算法
最新发布
05-14
C/C++，图算法——Dinic最大流量算法
最大流dinic算法
12-06
Dinic算法的基本思路: 1.根据残量网络计算层次图。 2.在层次图中使用DFS进行增广直到不存在增广路 3.重复以上步骤直到无法增广
最大流问题(EK算法)
weixin_44316314的博客
07-25 595
洛谷3376 给出一个网络图，以及其源点和汇点，求出其网络最大流。 EK算法： 在每条边都加了一条反向的，权值为0的边 反向边的作用：留下一个标记，让后面的流有机会让前面的流走另一条路。 直接从s到t广搜即可，从s开始不断向外广搜，通过权值大于0的边，直到找到t为止，(在过程中记录下每条边的编号)，然后找到该路径上边权最小的边，记为mi，然后最大流加mi，然后把该路径上的每一条边的边权减去mi，每...
最大流问题-EK算法
-
07-20 341
文章目录最大流问题解决问题概念性质增广路算法(EK算法)残量图增广路代码实现 最大流问题 解决问题         最大流的目的是将最多的物品从源点S通过其他点的中转，运送到汇点T，每条边具有能运送物品的上限。从S运送出来的物品数目等于到达T的物品数量。         针对图a，其中每条边代表运送物品的上上限，图b是其一个可行流(a / b, a是
网络流——最大流问题 EK算法
神回
10-14 732
网络流——最大流问题 EK算法题题：就像水从 s 流到 t ，给你每条边能流过的大小，问你 s —>t 最大能流多少？这就是最大流问题。增广路算法增广路算法，就是随便找 s->t的一条路，然后改变流过边的流量，再找另一条路直到找不到路算法过程如下图（图片来自http://blog.csdn.net/yiqingnian28/article/details/23388633 博客）看着这个图片很可
EK算法求最大流问题
weixin_60285599的博客
02-16 216
上一道裸题吧！ EK算法是基于增广路算法进行广搜。增广路是指在残差网络上的一条路径，每条边的权重都大于0。我们有如下的结论：如果残差网络中存在增广路，流量就可以增大（增广路定理）。所以我们从起始位置开始去搜索一条增广路径，找到后对残差网络进行更新，直到找不到增广路，那么此时得到的就是最大流的网络。 #include <iostream> #include <cstdlib> #include <cstdio> #include <cstring> ...
最大流问题(EK算法模板)
Jaster_wisdom的专栏
03-21 1144
最近在看 最大流问题，因为是第一次涉及到这种问题，以及第一次接触到这种类型的算法，所以刚开始一头雾水。 首先，这种问题概念比较多，残存网络，增广路径，最小割，流量对称，等。 其次，虽然有现成的方法解决，但是解决此方法的算法有多种，优化的算法也有很多。 刚开始看 Dinic 匈牙利算法，真心没看懂。。  现在我写了一份模板，是EK算法实现的。应该算最简单的一种实现方法了。我觉得，只要会熟练掌握
网络流最大流----EK算法
AC__dream的博客
08-21 1735
网络是指一个有向图G=（V,E），有两个特殊节点：源点S和汇点T。每条有向边(x,y)都有一个权值c(x,y),称为边的容量。如果（x,y）不在图中，那么就有c(x,y)=0.
网络流（最大流）EK算法
qq_40620465的博客
08-22 380
最大流问题： 假设需要把一些物品从节点s（称为源点） 运送到节点t（称为汇点） 可以从其他点进行中转，每两个点之间都有容量的限制，问从s到t，能运送的最大值是多少。 上图 从 1-4 最大流为 80 + 50 = 130 刘汝佳白书定义： 对于一条边（u，v）他的物品上限称为容量，记c（u，v）（对于不存在的边，c（u，v） = 0 ）；实际运送的物品称为流量（flow） 记f（u，...
最大流算法模板:EK和dinic算法
Jack_MaYun的博客
04-12 323
最大流算法模板:EK和dinic算法 一、EK算法模板 #include<iostream> #include<queue> using namespace std; const int maxn=205; const int inf=0x7fffffff; //图 int r[maxn][maxn]; //被访问点为true否则为false bool visit[maxn]; //pre[i] = j i点之前的点为j点 int pre[maxn]; int m,n; bool
Ek求最大流
qq_45832461的博客
08-05 251
EK求最大流 题目描述 核心思路 残留网络：残留网络G∗G^*G∗与原网络GGG的节点相同，GGG中的每条边都对应G∗G^*G∗中的一条或两条边。在残留网络中，与原网络对应的同向边是可增量（还可以增加多少流量），反向边是实际流量。 在残留网络中不显示0流量边，网络GGG及可行流对应的残留网络G∗G^*G∗如下图： 如下图所示，第一次从v1v_1v1​到v3v_3v3​流出了flow为6的流量，那么由于最大容量cap=10，那么下次还可以从v1v_1v1​到v3v_3v3​流出flow为10−6=41
最大流DInic算法的时间复杂度计算分析
06-12
Dinic算法是一种用于解决最大流问题的算法，其时间复杂度为O(V^2E)。其中，V表示图中的节点数，E表示图中的边数。 具体来说，Dinic算法的时间复杂度由两部分组成：构造分层图和在分层图上进行增广。构造分层图的时间复杂度为O(V+E)，在分层图上进行增广的时间复杂度为O(VE)。 在最坏情况下，每次增广都只能增加一条边的流量，因此需要进行O(V)次增广。因此，总时间复杂度为O(V^2E)。 需要注意的是，在实际应用中，Dinic算法的时间复杂度可能会更低，因为实际应用中的图通常比较稠密，即边数E比节点数V的平方还要大。此时，Dinic算法的时间复杂度可以近似为O(E^(3/2))。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值