「模板」网络最大流 FF && EK && Dinic && SAP && ISAP

最新推荐文章于 2022-02-08 11:38:55 发布
最新推荐文章于 2022-02-08 11:38:55 发布
阅读量76 收藏
点赞数
原文链接：http://www.cnblogs.com/Capella/p/8032583.html
版权

话不多说上代码。

Ford-Fulkerson(FF)

#include <algorithm>
#include <climits>
#include <cstdio>
#include <cstring>
using namespace std;
const int MAXN=100010,MAXM=200010;
bool vis[MAXN];
int n,m,S,T,cnt,ans,head[MAXN];
struct edge
{
    int nxt,to,w;
}e[MAXM];
void AddEdge(int x,int y,int w)
{
    e[++cnt].nxt=head[x];
    e[cnt].to=y;
    e[cnt].w=w;
    head[x]=cnt;
}
void AddEdges(int x,int y,int w)
{
    AddEdge(x,y,w);
    AddEdge(y,x,0);
}
int DFS(int x,int k)
{
    if(x==T)
        return k;
    vis[x]=1;
    for(int i=head[x],t,f;i;i=e[i].nxt)
        if(!vis[t=e[i].to] && e[i].w && (f=DFS(t,min(k,e[i].w))))
        {
            e[i].w-=f;
            e[((i-1)^1)+1].w+=f;
            return f;
        }
    return 0;
}
void FF()
{
    int f;
    while(memset(vis,0,sizeof vis),f=DFS(S,INT_MAX))
        ans+=f;
    while(0,1)
        printf("233");
    while(1)
    {
        memset(vis,0,sizeof vis);
        f=DFS(S,INT_MAX);
        if(!f)
            break;
        ans+=f;
    }
}
int main(int argc,char *argv[])
{
    scanf("%d %d %d %d",&n,&m,&S,&T);
    for(int i=1,x,y,w;i<=m;++i)
    {
        scanf("%d %d %d",&x,&y,&w);
        AddEdges(x,y,w);
    }
    FF();
    printf("%d\n",ans);
    return 0;
}

Edmonds-Karp(EK)

#include <algorithm>
#include <climits>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
const int MAXN=10010,MAXM=200010;
int n,m,S,T,cnt,ans,head[MAXN],flow[MAXN],pre[MAXN],pre_e[MAXN];
struct edge
{
    int nxt,to,w;
}e[MAXM];
void AddEdge(int x,int y,int w)
{
    e[++cnt].nxt=head[x];
    e[cnt].to=y;
    e[cnt].w=w;
    head[x]=cnt;
}
void AddEdges(int x,int y,int w)
{
    AddEdge(x,y,w);
    AddEdge(y,x,0);
}
bool BFS(int S)
{
    queue<int> q;
    memset(flow,0x7f,sizeof flow);
    memset(pre,0,sizeof pre);
    memset(pre_e,0,sizeof pre_e);
    q.push(S);
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        for(int i=head[x],t;i;i=e[i].nxt)
            if(!pre[t=e[i].to] && e[i].w)
            {
                q.push(t);
                pre[t]=x;
                pre_e[t]=i;
                flow[t]=min(flow[x],e[i].w);
            }
        if(pre[T])
            return 1;
    }
    return 0;
}
void EK()
{
    while(BFS(S))
    {
        for(int i=T,t;i!=S;i=pre[i])
        {
            e[t=pre_e[i]].w-=flow[T];
            e[((t-1)^1)+1].w+=flow[T];
        }
        ans+=flow[T];
    }
}
int main(int argc,char *argv[])
{
    scanf("%d %d %d %d",&n,&m,&S,&T);
    for(int i=1,x,y,w;i<=m;++i)
    {
        scanf("%d %d %d",&x,&y,&w);
        AddEdges(x,y,w);
    }
    EK();
    printf("%d",ans);
    return 0;
}

Dinic

#include <algorithm>
#include <climits>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
const int MAXN=10010,MAXM=200010;
bool vis[MAXN];
int n,m,S,T,cnt,ans,head[MAXN],dis[MAXN],cur[MAXN];
struct edge
{
    int nxt,to,w;
}e[MAXM];
void AddEdge(int x,int y,int w)
{
    e[++cnt].nxt=head[x];
    e[cnt].to=y;
    e[cnt].w=w;
    head[x]=cnt;
}
void AddEdges(int x,int y,int w)
{
    AddEdge(x,y,w);
    AddEdge(y,x,0);
}
bool BFS(int S)
{
    queue<int> q;
    memset(dis,0,sizeof dis);
    vis[S]=1;
    q.push(S);
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        for(int i=head[x],t;i;i=e[i].nxt)
            if(!vis[t=e[i].to] && e[i].w)
            {
                vis[t]=1;
                q.push(t);
                dis[t]=dis[x]+1;
            }
        if(dis[T])
            return 1;
    }
    return 0;
}
int DFS(int x,int k)
{
    if(x==T)
        return k;
    for(int i=cur[x],t,f;i;i=e[i].nxt)
        if(dis[t=e[i].to]==dis[x]+1 && e[i].w && (f=DFS(t,min(k,e[i].w))))
        {
            e[i].w-=f;
            e[((i-1)^1)+1].w+=f;
            cur[x]=i;
            return f;
        }
    return 0;
}
void Dinic()
{
    int f;
    while(memset(vis,0,sizeof vis),BFS(S))
        while(memcpy(cur,head,sizeof head),f=DFS(S,INT_MAX))
            ans+=f;
}
int main(int argc,char *argv[])
{
    scanf("%d %d %d %d",&n,&m,&S,&T);
    for(int i=1,x,y,w;i<=m;++i)
    {
        scanf("%d %d %d",&x,&y,&w);
        AddEdges(x,y,w);
    }
    Dinic();
    printf("%d",ans);
    return 0;
}

Shortest Augmenting Path(SAP)

#include <algorithm>
#include <climits>
#include <cstdio>
#include <queue>
using namespace std;
const int MAXN=10010,MAXM=200010;
bool vis[MAXN];
int n,m,S,T,cnt,ans,head[MAXN],cur[MAXN],pre[MAXN],pre_e[MAXN],dis[MAXN],gap[MAXN];
struct edge
{
    int nxt,to,w;
}e[MAXM];
void AddEdge(int x,int y,int w)
{
    e[++cnt].nxt=head[x];
    e[cnt].to=y;
    e[cnt].w=w;
    head[x]=cur[x]=cnt;
}
void AddEdges(int x,int y,int w)
{
    AddEdge(x,y,w);
    AddEdge(y,x,0);
}
void BFS(int T)
{
    queue<int> q;
    q.push(T);
    vis[T]=1;
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        for(int i=head[x],t;i;i=e[i].nxt)
            if(!dis[t=e[i].to] && !e[i].w)
            {
                vis[t]=1;
                dis[t]=dis[x]+1;
                q.push(t);
            }
    }
}
int Flow()
{
    int f=INT_MAX;
    for(int i=T;i!=S;i=pre[i])
        f=min(f,e[pre_e[i]].w);
    for(int i=T,t;i!=S;i=pre[i])
    {
        e[t=pre_e[i]].w-=f;
        e[((t-1)^1)+1].w+=f;
    }
    return f;
}
void SAP()
{
    BFS(T);
    for(int i=1;i<=n;++i)
        ++gap[dis[i]];
    int x=S;
    while(dis[S]<n)
    {
        if(x==T)
        {
            ans+=Flow();
            x=S;
        }
        bool flag=0;
        for(int i=cur[x],t;i;i=e[i].nxt)
            if(e[i].w && dis[x]==dis[t=e[i].to]+1)
            {
                flag=1;
                pre[t]=x;
                pre_e[t]=cur[x]=i;
                x=t;
                break;
            }
        if(!flag)
        {
            if(!--gap[dis[x]])
                break;
            int f=n-1;
            for(int i=head[x];i;i=e[i].nxt)
                if(e[i].w)
                    f=min(f,dis[e[i].to]);
            ++gap[dis[x]=f+1];
            cur[x]=head[x];
            if(x!=S)
                x=pre[x];
        }
    }
}
int main(int argc,char *argv[])
{
    scanf("%d %d %d %d",&n,&m,&S,&T);
    for(int i=1,x,y,w;i<=m;++i)
    {
        scanf("%d %d %d",&x,&y,&w);
        AddEdges(x,y,w);
    }
    SAP();
    printf("%d",ans);
    return 0;
}

Improved Shortest Augmenting Path(ISAP)

#include <algorithm>
#include <climits>
#include <cstdio>
using namespace std;
const int MAXN=10010,MAXM=200010;
int n,m,S,T,cnt,ans,head[MAXN],cur[MAXN],pre[MAXN],pre_e[MAXN],dis[MAXN],gap[MAXN];
struct edge
{
    int nxt,to,w;
}e[MAXM];
void AddEdge(int x,int y,int w)
{
    e[++cnt].nxt=head[x];
    e[cnt].to=y;
    e[cnt].w=w;
    head[x]=cur[x]=cnt;
}
void AddEdges(int x,int y,int w)
{
    AddEdge(x,y,w);
    AddEdge(y,x,0);
}
int Flow()
{
    int f=INT_MAX;
    for(int i=T;i!=S;i=pre[i])
        f=min(f,e[pre_e[i]].w);
    for(int i=T,t;i!=S;i=pre[i])
    {
        e[t=pre_e[i]].w-=f;
        e[((t-1)^1)+1].w+=f;
    }
    return f;
}
void ISAP()
{
    for(int i=1;i<=n;++i)
        ++gap[dis[i]];
    int x=S;
    while(dis[S]<n)
    {
        if(x==T)
        {
            ans+=Flow();
            x=S;
        }
        bool flag=0;
        for(int i=cur[x],t;i;i=e[i].nxt)
            if(e[i].w && dis[x]==dis[t=e[i].to]+1)
            {
                flag=1;
                pre[t]=x;
                pre_e[t]=cur[x]=i;
                x=t;
                break;
            }
        if(!flag)
        {
            if(!--gap[dis[x]])
                break;
            int f=n-1;
            for(int i=head[x];i;i=e[i].nxt)
                if(e[i].w)
                    f=min(f,dis[e[i].to]);
            ++gap[dis[x]=f+1];
            cur[x]=head[x];
            if(x!=S)
                x=pre[x];
        }
    }
}
int main(int argc,char *argv[])
{
    scanf("%d %d %d %d",&n,&m,&S,&T);
    for(int i=1,x,y,w;i<=m;++i)
    {
        scanf("%d %d %d",&x,&y,&w);
        AddEdges(x,y,w);
    }
    ISAP();
    printf("%d",ans);
    return 0;
}

转载于:https://www.cnblogs.com/Capella/p/8032583.html

网络流讲解（dinic）
weixin_39971710的博客
07-19 594
1.网络流是什么？ 最大流（也称最小割）： 有一个有向图，其中有两个特殊点源点和汇点，每条边都有它的容量，求从源点到汇点的最大流量。 2.如何实现？ Dinic: 时间复杂度：O(mn²) 大致流程： 1.建立网络，正向弧，反向弧（初始化边权为0），总流量初始化为0； 2.分层，分出每个点的层，也就是那...
最大流的基本算法（ff算法&&dinic算法&&push-rebeal算法）poj1273
aaron_1996的专栏
08-08 3051
最大流的基本概念有以下几点：               1.残存网络：即为一条管道被占用了一部分流量之后所剩下的流量。在网络流中，图被看为一个有向图，残存流量向量相加后永远不变。这一点有点像基尔霍夫定律。               2.在找到一个流之后，仍然存在的从源点到汇点的路径。这叫做增广路径。加入增广路径后，流的容量一定能够提升。寻找增广路径一般使用DFS或BFS。 ford-fu
图论--网络流最大流问题
日拱一卒,功不唐捐
10-28 7970
问题表述：给定一幅图（n个结点，m条边），每一条边有一个容量，现在需要将一些物品从结点s（称为源点）运送到结点t（称为汇点），可以从其他结点中转，求最大的运送量。 在介绍最大流问题的解决方法之前，先介绍几个概念. 网络：网络是一个有向带权图，包含一个源点和一个汇点，没有反向平行边。 网络流：网络流即网上的流，是定义在网络边集E上的一个非负函数flow={flow（u，v）}, flow（u,...
【网络流总结 Ⅰ】【概况】【最大流总结】| N
Keyu Tian's blog
05-29 382
今天就来看看这些最大流板子里到底都是嘛玩意.. 网络流总结Ⅰ：概况 | 最大流 网络流 是图论中比较独立的一块，其算法基础不难，问题也相对具体，但编程复杂度不低，且其相关问题变化莫测、种类繁多，解题的难点往往在于对题目的抽象、转化与化归。因此需积累一定的题量和思考量，再加以总结，才可较为灵活地掌握这类算法问题。
poj3281Dining网络流-最大流
When you go away
07-30 668
就向之前那篇博客写得一样,这里就是需要拆点的.把
网络流之最大流入门-POJ1459PowerNetwork-Dinic模板
打过ICPC/CCPC，学习ACM算法，Linux内核，Openharmony，加油努力开心珍惜
04-18 475
(我有什么错误或者你有什么意见，欢迎留言或私聊！谢谢！) (Ps:以前听说过网络流，想着以后再学，这次中南多校赛也碰到有关网络流的题目，想着这两天试着学学这个吧~~ 这是本人网络流入门第二题，不知道怎么解释，给大家推荐几个博客方便大家入门网络流： 网络流入门博客1 网络流入门博客2 看之前大家可以去百度一下网络流入门术语，这对新手入门网络流会有一些帮助） 题意： 用人话解释： 1...
网络流入门-POJ1459PowerNetwork-最大流模板
ako2654的博客
04-18 115
(我有什么错误或者你有什么意见，欢迎留言或私聊！谢谢！) (Ps:以前听说过网络流，想着以后再学，这次中南多校赛也碰到有关网络流的题目，想着这两天试着学学这个吧~~ 这是本人网络流入门第二题，不知道怎么解释， 给大家推荐几个博客方便大家入门网络流： 网络流入门博客1 网络流入门博客2 看之前大家可以去百度一下网络流入门术语，这对新手入门网络流会有一些帮助） ...
网络流及其算法
Evan_song1234的博客
02-08 1801
网络流 源点 流量为 inf⁡\infinf 的一个点，网络流起点，一般用 sss 表示。 汇点 接收流量的一个点，网络流终点。 弧 一条有向边。 弧的流量 实际通过这条弧的流量。 弧的容量 指的是一条弧的最大流量。 网络流 所有弧上流量的集合。 增广路径 从源点 sss 到汇点 ttt 的一条可以有流量的路径。 可行弧 也成允许弧，当 (i,j)(i, j)(i,j) 为一个可行弧时，di=dj+1d_i=d_j+1di​=dj​+1，ddd 为当前点 bfsbfsbfs 时的深度 可行流 一张图能够达成
最大流模板
You and me
08-21 311
最近学习了最大流虽然学的一般都是会简单的使用，一下是我用过的几个模板 模板一sap： #include &lt;bits/stdc++.h&gt; /* 用maze来存图 */ typedef long long ll; using namespace std; const int MAXN=1100; int maze[MAXN][MAXN]; int gap[MAXN],dis[MAXN...
Dinic.rar_Dinif2.m_dinic_最大流_最大流算法_最大网络流
07-15
本文将详细介绍Dinic算法，这是一种高效的求解网络最大流的算法。 首先，我们要理解什么是最大流。在网络流问题中，我们有一个带权重的有向图，其中每个边代表一个可以传输流量的连接，每条边都有一个容量限制。...
网络流dinic模板
02-24
网络流dinic模板，非本人原创。网络流dinic模板，非本人原创
我的模板 最大流（Dinic & Isap）+最小费用最大流（SPFAFlow）==有更改
志当存高远
08-10 4591
今天刻意用poj 3469 http://poj.org/problem?id=3469测了下模板，Isap并不像想象中那么快，难道是我写搓了，而且在网络流与线性规划中的最后一题，isap完败给Dinic了,我的Isap啊~~~不知道那些几百毫秒出解的是用什么算法。。。难道是。。。    dinic总体上挺不错的，递归版的Isap基本上与Dinic没差别，而非递归版在某些情况反而不如递归版，于是
中国行政村区划代码及地理坐标-最新数据.zip
最新发布
11-17
中国行政村区划代码及地理坐标-最新数据.zip
pocketsphinx-0.1.15-cp35-cp35m-win_amd64.whl.rar
11-17
python whl离线安装包 pip安装失败可以尝试使用whl离线安装包安装 第一步 下载whl文件，注意需要与python版本配套 python版本号、32位64位、arm或amd64均有区别 第二步 使用pip install XXXXX.whl 命令安装，如果whl路径不在cmd窗口当前目录下，需要带上路径 WHL文件是以Wheel格式保存的Python安装包， Wheel是Python发行版的标准内置包格式。 在本质上是一个压缩包，WHL文件中包含了Python安装的py文件和元数据，以及经过编译的pyd文件， 这样就使得它可以在不具备编译环境的条件下，安装适合自己python版本的库文件。 如果要查看WHL文件的内容，可以把.whl后缀名改成.zip，使用解压软件（如WinRAR、WinZIP）解压打开即可查看。 为什么会用到whl文件来安装python库文件呢？ 在python的使用过程中，我们免不了要经常通过pip来安装自己所需要的包， 大部分的包基本都能正常安装，但是总会遇到有那么一些包因为各种各样的问题导致安装不了的。 这时我们就可以通过尝试去Python安装包大全中（whl包下载）下载whl包来安装解决问题。
中国固定资产投资统计年鉴全集（1950-2021）.zip
11-17
中国固定资产投资统计年鉴全集（1950-2021）.zip
常用基础元件的PCB封装库SchLib/IntLib通用原理图库OV系列CMOS图像传感器
11-17
常用基础元件的PCB封装库SchLib/IntLib通用原理图库OV系列CMOS图像传感器提取方式是百度网盘分享地址
c++控制台RPG小游戏
11-17
这是一个比较完成的RPG游戏，包含了： 交易模块, 任务模块,技能模块,BUFF 模块, 背包模块,地图模块,基本涵盖了一个普通RPG游戏的所有元素
yolo算法-人-火灾数据集-9700张图像带标签-人-火灾.zip
11-17
yolo系列算法目标检测数据集，包含标签，可以直接训练模型和验证测试，数据集已经划分好，包含数据集配置文件data.yaml，适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法； 包含两种标签格:yolo格式（txt文件）和voc格式（xml文件），分别保存在两个文件夹中; yolo格式：<class> <x_center> <y_center> <width> <height>， 其中： <class> 是目标的类别索引（从0开始）。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标，这些坐标是相对于图像宽度和高度的比例值，范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度，也是相对于图像宽度和高度的比例值
Dinic's Algorithm with Optimizations: Flow Templates & Efficient Implementation
这个模板包含了三种不同版本的Dinic SAP，使得开发者能够根据具体需求选择或混合使用这些优化技术来处理各种网络流问题，特别是那些具有挑战性的实例，如基本的所有网络流题目。 在使用时，注意先调用`init()`初始...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值