网络流模板 Dinic ISAP HLPP 最小费用最大流 最小割 建图技巧

最新推荐文章于 2020-08-19 18:19:36 发布
最新推荐文章于 2020-08-19 18:19:36 发布
阅读量680 收藏 13
点赞数 2
分类专栏： 网络流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiji333/article/details/102828419
版权

文章目录

参考博客：

网络流基础知识及经典算法(这个内容比较详细 虽然有一些重复的知识点？)
最大流、费用流基础知识(这个比较简短 而且有残余网络的图示 可以结合上面那个一起学习 加深理解 不过它的图 1 1 1有个地方写错了~)
D i n i c Dinic Dinic的当前弧优化
I S A P 与 H L P P ISAP与HLPP ISAP与HLPP
H L P P HLPP HLPP
H L P P HLPP HLPP
最大流最小割

最大流模板：

D i n i c ： Dinic： Dinic：

复杂度上限为 O ( n 2 m ) O(n^2m) O(n2m)，不过这个上限比较松。

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
                            //Dinic模板 除了顶点数和变数 基本不需要改动什么
const int maxn=1e4+5;
const int maxm=1e5+5;

struct Edge
{
	int to,nxt,f;
};      //前向星存边
Edge edge[maxm<<1]; //边的空间至少要开两倍 因为有反向边的存在
int head[maxn],cur[maxn];//cur用于当前弧优化
int tot=1; //边的编号
int depth[maxn]; //用于bfs分层
int n,m,s,t; //定点数 边数 源点 汇点

inline void addedge(int u,int v,int dis) //加一条 u->v 容量为dis的边 那么自然要加一条 v->u 流量为0的反向边
{
	edge[++tot].to=v,edge[tot].f=dis;
	edge[tot].nxt=head[u];
	head[u]=tot;
	edge[++tot].to=u,edge[tot].f=0;
	edge[tot].nxt=head[v];
	head[v]=tot;
}

bool bfs() //bfs分层
{
	memcpy(cur,head,sizeof(cur));//当前弧优化要用到
	memset(depth,0,sizeof(depth));//初始化为0或-1均可 看个人习惯
	queue<int> q;
	depth[s]=1; //源点
	q.push(s);
	int fir,to;
	while(!q.empty())
	{
		fir=q.front();
		q.pop();
		for(int i=head[fir];i;i=edge[i].nxt)
		{
			to=edge[i].to;
			if(edge[i].f&&!depth[to]) //对于前向边来说 该边的流量未满 对于后向边来说 该边有流量可退回
			{
				depth[to]=depth[fir]+1;
				q.push(to);
			}
		}
	}
	return depth[t];
}
                      //dfs 寻找多条增广路
int dfs(int u,int lim)//当前节点 当前流量
{
	if(u==t)//汇点
		return lim;
	int v,temp,ans=0;
	for(int i=cur[u];i;i=edge[i].nxt)
	{
		cur[u]=i; //当前弧优化
		v=edge[i].to;
		if(depth[v]==depth[u]+1&&edge[i].f)
		{
			temp=dfs(v,min(lim,edge[i].f));
			edge[i].f-=temp;
			edge[i^1].f+=temp;
			ans+=temp;
			lim-=temp; //多路增广 EK算法在此处已经return了
			if(!lim) //流入当前节点的流量已经用完了 就没必要继续寻找增广路了
				break;
		}
	}
	if(lim||!ans) //流没用完 或者该点对答案没有任何贡献 以后也没必要访问该点
		depth[u]=0;
	return ans;
}

int dinic()
{
	int ans=0; //答案
	while(bfs()) //分层
		ans+=dfs(s,INF); //dfs找增广路
	return ans;
}

int main()
{
	while(~scanf("%d %d %d %d",&n,&m,&s,&t))
	{
		memset(head,0,sizeof(head));
		tot=1;
		int u,v,c;
		for(int i=0;i<m;i++)
		{
			scanf("%d%d%d",&u,&v,&c);
			addedge(u,v,c);
		}
		printf("%d\n",dinic());
	}
	return 0;
}

I S A P ： ISAP： ISAP：

只进行 1 1 1次 b f s bfs bfs，复杂度更加优秀！

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
                            //ISAP模板 除了需要改变顶点数和边数
                            //还要改变 isap() 函数中循环体的判断
                            //和 dfs() 对depth数组的更改
const int maxn=1e4+5;
const int maxm=1e5+5;

struct Edge
{
	int to,nxt,f;
};      //前向星存边
Edge edge[maxm<<1]; //边的空间至少要开两倍 因为有反向边的存在
int head[maxn],cur[maxn];//cur用于当前弧优化
int tot=1; //边的编号
int depth[maxn],cnt[maxn];
int n,m,s,t; //定点数 边数 源点 汇点

inline void addedge(int u,int v,int dis) //加一条 u->v 容量为dis的边 那么自然要加一条 v->u 流量为0的反向边
{
	edge[++tot].to=v,edge[tot].f=dis;
	edge[tot].nxt=head[u];
	head[u]=tot;
	edge[++tot].to=u,edge[tot].f=0;
	edge[tot].nxt=head[v];
	head[v]=tot;
}

void bfs() //bfs处理出深度
{
	memset(depth,0,sizeof(depth));
	memset(cnt,0,sizeof(cnt));
	queue<int> q;         //注意 此处是从汇点开始
	depth[t]=1,cnt[1]=1; //汇点
	q.push(t);
	int fir,to;
	while(!q.empty())
	{
		fir=q.front();
		q.pop();
		for(int i=head[fir];i;i=edge[i].nxt)
		{
			to=edge[i].to;
			if(edge[i].f&&!depth[to])
			{
				depth[to]=depth[fir]+1;
				++cnt[depth[to]];
				q.push(to);
			}
		}
	}
}

int dfs(int u,int lim)//当前节点 当前流量
{
	if(u==t)//汇点
		return lim;
	int v,temp,ans=0;
	for(int i=cur[u];i;i=edge[i].nxt)
	{
		cur[u]=i; //当前弧优化
		v=edge[i].to;
		if(depth[v]==depth[u]-1&&edge[i].f)
		{
			temp=dfs(v,min(lim,edge[i].f));
			edge[i].f-=temp;
			edge[i^1].f+=temp;
			ans+=temp;
			lim-=temp; //多路增广
			if(!lim) //流入当前节点的流量已经用完了 就没必要继续寻找增广路了
				break;
		}
	}
	if(lim||!ans) //流没用完 或者该点对答案没用任何贡献
    {
        if(--cnt[depth[u]]==0)
            depth[s]=n+1;
        ++cnt[++depth[u]];
    }
	return ans;
}

int isap()
{
	int ans=0; //答案
    bfs();
	while(depth[s]<=n) //分层 此处视 顶点个数 不同需要改变
	{
	    memcpy(cur,head,sizeof(cur));
        ans+=dfs(s,INF); //dfs找增广路
	}
	return ans;
}

int main()
{
	while(~scanf("%d %d %d %d",&n,&m,&s,&t))
	{
		memset(head,0,sizeof(head));
		tot=1;
		int u,v,c;
		for(int i=0;i<m;i++)
		{
			scanf("%d%d%d",&u,&v,&c);
			addedge(u,v,c);
		}
		printf("%d\n",isap());
	}
	return 0;
}

H L P P ： HLPP： HLPP：

时间复杂度 O ( n 2 m ) O(n^2\sqrt{m}) O(n2m ​)，不过这个上限比较紧，一般来说 D i n i c Dinic Dinic和 I S A P ISAP ISAP就够了，除非毒瘤出题人卡了前两个算法。

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

const int maxn=2e3+5;
const int maxm=2e5+5;

struct Edge
{
	int to,nxt,f;
}edge[maxm<<1];

int n,m,s,t,tot;
int head[maxn],depth[maxn],rest[maxn],inque[maxn],cnt[maxn<<1];

struct cmp
{
    inline bool operator ()(int a,int b)const
    {
        return depth[a]<depth[b];
    }
};

priority_queue<int,vector<int>,cmp> q;

inline int read() //注意 该快读省去了负数的情况
{
    char ch=getchar();
    while(ch<'0'||ch>'9')
        ch=getchar();
    int ans=0;
    while(ch>='0'&&ch<='9')
    {
        ans=(ans<<3)+(ans<<1)+ch-48;
        ch=getchar();
    }
    return ans;
}

inline void addedge(int u,int v,int dis)
{
    edge[++tot].to=v,edge[tot].f=dis;
	edge[tot].nxt=head[u];
	head[u]=tot;
	edge[++tot].to=u,edge[tot].f=0;
	edge[tot].nxt=head[v];
	head[v]=tot;
}

void bfs()
{
    queue<int> que;
    memset(cnt,0,sizeof(cnt));
    memset(depth,0,sizeof(depth));
    depth[t]=1,cnt[1]=1;
    que.push(t);
    while(!que.empty())
    {
        int u=que.front();
        que.pop();
        for(int i=head[u];i;i=edge[i].nxt)
        {
            int v=edge[i].to;
            if(!depth[v])
            {
                depth[v]=depth[u]+1;
                ++cnt[depth[v]];
                que.push(v);
            }
        }
    }
}

inline void out(int u)//推流
{
    int flow;
    for(int i=head[u];i;i=edge[i].nxt)
    {
        int v=edge[i].to;
        if(edge[i].f&&depth[u]==depth[v]+1)
        {
            flow=min(edge[i].f,rest[u]); //边的流量 u点的余流
            edge[i].f-=flow;
            edge[i^1].f+=flow;
            rest[u]-=flow;
            rest[v]+=flow;
            if(v!=s&&v!=t&&!inque[v])//如果v不是源点不是汇点且不在优先队列中则入队
                q.push(v),inque[v]=1;
            if(!rest[u]) //节点u 已没有余流可推
                break;
        }
    }
    return ;
}

inline void relable(int u)//修改深度
{
    depth[u]=INF;
    for(int i=head[u];i;i=edge[i].nxt)
    {
        int v=edge[i].to;
        if(edge[i].f&&depth[v]+1<depth[u])
            depth[u]=depth[v]+1;
    }
    return ;
}

int hlpp()
{
    bfs();
    if(depth[s]==0) //可以判断一下连通性
        return 0;
    depth[s]=n;
    memset(rest,0,sizeof(rest));
    memset(inque,0,sizeof(inque));
    for(int i=head[s];i;i=edge[i].nxt)//源点s向 邻接点推流
    {
        int u=edge[i].to;
        if(edge[i].f)
        {
            rest[u]+=edge[i].f;
            swap(edge[i].f,edge[i^1].f);
            if(u!=s&&u!=t&&!inque[u])
                q.push(u),inque[u]=1;
        }
    }
    while(!q.empty()) //按照高度 依次推流
    {
        int u=q.top();
        q.pop();
        inque[u]=0;
        out(u); //推流
        if(rest[u])
        {
            if(--cnt[depth[u]]==0)
            {
                for(int i=1;i<=n;i++)
                    if(i!=s&&i!=t&&depth[i]>depth[u]&&depth[i]<=n)
                        depth[i]=n+1;
            }
            relable(u);
            ++cnt[depth[u]];
            q.push(u);
            inque[u]=1;
        }
    }
    return rest[t];
}

int main()
{
    while(~scanf("%d %d %d %d",&n,&m,&s,&t))
    {
        tot=1;
        memset(head,0,sizeof(head));
        int u,v,w;
        for(int i=0;i<m;i++)
        {
            u=read(),v=read(),w=read();
          //  scanf("%d %d %d",&u,&v,&w);
            addedge(u,v,w);
        }
        printf("%d\n",hlpp());
    }
}

最小费用最大流：

S P F A SPFA SPFA版本：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define INF 0x3f3f3f3f
using namespace std;

const int maxn=5005;
const int maxm=50005;

struct Edge
{
	int to,nxt,f,w;
}edge[maxm<<1];

int n,m,s,t,tot;
int head[maxn]; //前向星
int dis[maxn],pre[maxn],maxf[maxn],inque[maxn];//dis用于最短路 pre记录前驱边 maxf记录最小剩余容量 inque记录是否在队列中

inline void addedge(int u,int v,int c,int w)//容量为c 权值为w
{
	edge[++tot].to=v,edge[tot].f=c,edge[tot].w=w,edge[tot].nxt=head[u],head[u]=tot;
	edge[++tot].to=u,edge[tot].f=0,edge[tot].w=-w,edge[tot].nxt=head[v],head[v]=tot;
}

bool spfa()
{
	queue<int> q;
	q.push(s);
	memset(dis,INF,sizeof(dis));
	dis[s]=0,inque[s]=1,maxf[s]=INF;//源点流量无限大
	while(!q.empty())
	{
		int u=q.front();
		q.pop(),inque[u]=0;;
		for(int i=head[u];i;i=edge[i].nxt)
		{
		    int v=edge[i].to;
			if(edge[i].f&&dis[u]+edge[i].w<dis[v])
			{
				dis[v]=dis[u]+edge[i].w;
				pre[v]=i; //记录前驱边
				maxf[v]=min(maxf[u],edge[i].f);//流入v的流量等于 二者的最小值
				if(!inque[v])
					inque[v]=1,q.push(v);
			}
		}
	}
	if(dis[t]<INF)
		return 1;
	return 0;
}

void MCMF()
{
	int mflow=0,mcost=0;
	while(spfa())
	{
		int u=t,v;
		while(u!=s)
		{
			v=pre[u];
			edge[v].f-=maxf[t];
			edge[v^1].f+=maxf[t];
			u=edge[v^1].to;
		}
		mflow+=maxf[t];
		mcost+=dis[t]*maxf[t];
	}
	printf("%d %d\n",mflow,mcost);
}

int main()
{
	while(~scanf("%d%d%d%d",&n,&m,&s,&t))
	{
		tot=1;
		memset(head,0,sizeof(head));
		int u,v,f,w;
		for(int i=0;i<m;i++)
		{
			scanf("%d%d%d%d",&u,&v,&f,&w);
			addedge(u,v,f,w);
		}
		MCMF();
	}
}

割与最小割：

在这里插入图片描述
还是不懂割是什么？看图：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
如果是求割点怎么办？（转自洛谷）
在这里插入图片描述在这里插入图片描述

建模技巧选讲

多源多汇

在这里插入图片描述

无向图

在这里插入图片描述

顶点也有流量限制

在这里插入图片描述

最大权闭合子图

在这里插入图片描述
u p d a t e ： update： update：有一处笔误，应该是源点向正权点连边，负权点向汇点连容量为其权值绝对值的边。
结论就是最大权闭合子图的权值=子图内正权值之和-最小割
证明如下：
在这里插入图片描述

区间 k k k次覆盖

在这里插入图片描述
在这里插入图片描述
坐标过大的话需要离散化。

csu_xiji
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图论-网络流⑦-费用流解题
KonnyWen的博客
02-17 509
图论-网络流⑦-费用流解题① 上一篇：图论-网络流⑥-费用流① 下一篇：未完待续 参考文献： 暂无 大纲 什么是网络流 最大流（最小割） DinicDinicDinic （常用） EKEKEK SapSapSap Ford−FulkersonFord-FulkersonFord−Fulkerson（不讲） HLPPHLPPHLPP （快） 最大流解题 费用流 EKEKEK...
网络流（最大流和最小费用流）
thy0311的专栏
07-20 4311
几个月前学过，然而一下就忘记了，于是决定系统的复习一下。 关于网络流各路神犇早已有很好的讲解，于是我就整理一下（其实我是蒟蒻，看到的果断关掉吧） http://blog.csdn.net/leolin_/article/details/7202691 残余网络： 两个点之间有一个流的限制，那么假如有一个流流过，那么残余网络记录的是在进行几次操作之后，两点间还可以通过多少。 增广路径：（
最大流(模板EK,dinic,isap)+最小费用最大流(spfa)
qq_44077455的博客
03-03 266
模板题 这三种算法基于寻找增广路径来求解最大流，当一个网络图中不存在增广路径时我们就得到了最大流； 1.EK: //直接使用bfs找最近的增广路径，每找到一条就更新残余网络，然后继续找，直到不存在为止，这个真好懂^ V ^ #include<bits/stdc++.h> #include<iostream> #include<algorithm> #includ...
费用流——洛谷P3381 【模板】最小费用最大流
我怎么这么菜的呢
06-12 1136
https://daniu.luogu.org/problem/show?pid=3381 我学习了EK算法之后发现别人都学zkw的我靠； 跑的比我快我靠； 思想就是每次sfpa找到一条可以增广并且费用最小的路； 然后暴力修改这条路上的信息；#include<bits/stdc++.h> #define Ll long long using namespace std; const int
网络流最小费用流模板
自强不息 厚德载物
05-27 208
#include&lt;cstdio&gt; #include&lt;vector&gt; #include&lt;queue&gt; #include&lt;algorithm&gt; #include&lt;cstring&gt; #define REP(i, a, b) for(int i = (a); i &lt; (b); i++) using namespace std; typ...
网络流最大流Dinic算法代码
10-16
最大流的Dinic算法，时间复杂度O(EV^2),代码简单而高效
Dinic.rar_Dinif2.m_dinic_最大流_最大流算法_最大网络流
07-15
本文将详细介绍Dinic算法，这是一种高效的求解网络最大流的算法。 首先，我们要理解什么是最大流。在网络流问题中，我们有一个带权重的有向图，其中每个边代表一个可以传输流量的连接，每条边都有一个容量限制。...
最大网络流Dinic算法
09-01
最大网络流问题在图论和运筹学中占有重要地位，它主要研究在一个有向图中，从源点到汇点能通过的最大流量。Dinic算法是由苏联计算机科学家E. A. Dinic于1970年提出的，是一种解决此类问题的有效算法。该算法基于层的...
网络流dinic模板
02-24
网络流dinic模板，非本人原创。网络流dinic模板，非本人原创
网络流，最小费用最大流
07-18
详细的介绍了最大流问题的基本概念与解法。 图文并茂地介绍Dinic算法原理与流程并且附上模板。 最小费用最大流的算法思想、想解例题和模板。
最小费用最大流模板
11-26
最小费用最大流模板
费用流：最大费用最大流和最小费用最大流(模板)
Falcon的博客
11-22 1047
主要是思维建边，建有向边，然后跑模板就行了 可以解决KM算法所能解决的问题(完全取代) 可以解决非完备匹配问题中的最大权匹配和最小权匹配，分别对应着最大费用最大流和最小费用最大流 模板： 最大费用最大流： const int N=1e5+100;//点 const int M=1e5+100;//边 struct Edge { int to,w,cost,next; }edge[...
SAP和ISAP（网路最大流的两个增广路算法）
严霜九月
02-02 1863
ISAP是对SAP进行优化后的算法，ISAP时间复杂度为O(V^2E)，SAP的时间复杂度为O(VE^2)   SAP #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;iomanip&gt; #include &lt;queue&gt; using namespace std; const int ...
从Dinic到ISAP，从余流推进到最高标号的预留推进HLPP（究极最大流算法）
既然弱小，就只顾变强就是了
01-22 1905
题目链接——很好的一道对于网络流提升的题 Dinic 首先，这道题真的将Dinic算法卡到了它的上界，也就是，在这道题中，使用一般的Dinic最后会获得40分。 #include <iostream> #include <cstdio> #include <cmath> #include <string> #include <cst...
网络流--最大流--hlpp（预流推进）模板
日拱一卒,功不唐捐
11-01 2690
//500ms 秒掉洛谷推流问题 #include <algorithm> #include <iostream> #include <cstring> #include <vector> #include <queue> using namespace std; typedef long long LL; typedef long l...
网络流算法（Dinic，Ispa，Hlpp）小结
trouble_的博客
05-15 1361
网络流所能解决的问题:   给定一个有向图，有两个特殊的点，源点S，汇点T，每条边有指定的容量，求从S流向T的最大流量是什么？ 求解思路： 解决该问题的算法： Dinic算法：   算法步骤: bfs标记深度，dfs查找增广路，再bfs，dfs，bfs，dfs，…，直到bfs无法进行，遇到断层，算法结束 代码模板（洛谷：P3376）： #include <bits/stdc++.h> #define INF INT_MAX using namespace std; typedef long
最大流（Edmonds-Karp，Dinic，ISAP，Push-Relabel 预流推进算法）
繁凡さん的博客
08-19 1970
整理的算法模板合集： ACM模板 目录Edmonds−KarpEdmonds-KarpEdmonds−KarpDinicDinicDinicISAPISAPISAPPush−RelabelPush-RelabelPush−Relabel 预流推进算法通用的预流推进算法HLPP 算法 Edmonds−KarpEdmonds-KarpEdmonds−Karp EK 算法的时间复杂度为O(nm2)O(nm^2)O(nm2)，一般可以处理10310^3103 ~ 10410 ^4104的数据 /*luogu P2
基础网络流题单
weixin_30588907的博客
01-24 84
一、一些好的博客 EK、MCMF Dinic、MCMF优化 ISAP、HLPP 二、题单 最大流 1.Luogu P2472 [SCOI2007]蜥蜴 题解 2.Luogu P2604 [ZJOI2010]网络扩容 题解 3.Luogu P3931 SAC E#1 - 一道难题 Tree 题解 4.Luogu P2763 试题库问题 题解 5.Luogu P2766 最长不下降子序列...
最大流Edmondes-Karp,hlpp代码(2007-04-16 19:49)
ecchi's blog
11-05 553
  搞了一下午总算写出来了= =...刚开始学网络流,也不知道要怎么样优化,贴上随便写的代码~继续搞rtf...------------------------Edmondes-Karp--------------------------------#include "stdio.h" #include "string.h" int rm[201][201];

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值