【图论】网络流一些模板

最新推荐文章于 2022-02-03 17:56:32 发布
最新推荐文章于 2022-02-03 17:56:32 发布
阅读量208 收藏
点赞数 1
分类专栏： 图论 网络流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Rainfoo/article/details/108296081
版权

AcWing.2188 无源汇上下界可行流

#include<bits/stdc++.h>
#pragma GCC optimize(2)
#define ll long long
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,n,a) for(int i=n;i>=a;i--)
#define endl '\n'
#define eps 0.000000001
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))
#define IO ios::sync_with_stdio(false);cin.tie(0);
using namespace std;
const int INF=0x3f3f3f3f;
const ll inf=0x3f3f3f3f3f3f3f3f;
const int mod=1e9+7;
const int N=210;
const int M=(10200+N)*2;
int n,m,S,T;
int head[N],d[N],cur[N],tot;
struct E{
	int to,next,cap,low;
}edge[M];
void add(int u,int v,int c,int d){
	edge[tot].to=v;
	edge[tot].next=head[u];
	edge[tot].cap=d-c;
	edge[tot].low=c;
	head[u]=tot++;
	edge[tot].to=u;
	edge[tot].next=head[v];
	edge[tot].cap=0;
	head[v]=tot++;	
}
bool bfs(){
	memset(d,-1,sizeof(d));	
	queue<int> q;
	q.push(S);d[S]=0;cur[S]=head[S];
	while(!q.empty()){
		int u=q.front();q.pop();
		for(int i=head[u];i!=-1;i=edge[i].next){
			int v=edge[i].to;
			if(d[v]==-1&&edge[i].cap){
				d[v]=d[u]+1;
				cur[v]=head[v];
				if(v==T) return true;
				q.push(v);
			}			
		}
	}
	return false;
}
int dfs(int u,int limit){
	if(u==T) return limit;
	int flow=0;
	for(int i=cur[u];i!=-1&&flow<limit;i=edge[i].next){
		cur[u]=i;
		int v=edge[i].to;
		if(d[v]==d[u]+1&&edge[i].cap){
			int delta=dfs(v,min(edge[i].cap,limit-flow));
			if(!delta) d[v]=-1;
			edge[i].cap-=delta;
			edge[i^1].cap+=delta;
			flow+=delta;
		}
	}
	return flow;
}
int dinic(){
	int maxFlow=0,delta;
	while(bfs()){
		while(delta=dfs(S,INF)){
			maxFlow+=delta;
		}
	}
	return maxFlow;  	
}
int A[N];
int main(){
	cin>>n>>m;mem(head,-1);
	S=0,T=n+1;
	rep(i,1,m){
		int a,b,c,d;
		cin>>a>>b>>c>>d;
		add(a,b,c,d);
		A[a]-=c;A[b]+=c;	
	}
	int num=0;
	rep(i,1,n){
		if(A[i]>0) add(S,i,0,A[i]),num+=A[i];
		else if(A[i]<0) add(i,T,0,-A[i]);
	}
	if(dinic()!=num) puts("NO");
	else{
		puts("YES");
		for(int i=0;i<m*2;i+=2){
			cout<<edge[i^1].cap+edge[i].low<<endl;
		}
	}
	return 0;
}

AcWing.2189有源汇上下界最大流模板

#include<bits/stdc++.h>
#define ll long long
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,n,a) for(int i=n;i>=a;i--)
#define endl '\n'
#define mem(a) memset(a,0,sizeof(a))
#define IO ios::sync_with_stdio(false);cin.tie(0);
using namespace std;
const int INF=0x3f3f3f3f;
const int mod=1e9+7;
const int N=210;
const int M=(N+10000)*2;
int n,m,S,T;
int head[N],d[N],cur[N],A[N],tot;
struct E{
	int to,next,cap;
}edge[M];
void add(int u,int v,int w){
	edge[tot].to=v;
	edge[tot].next=head[u];
	edge[tot].cap=w;
	head[u]=tot++;
	edge[tot].to=u;
	edge[tot].next=head[v];
	edge[tot].cap=0;
	head[v]=tot++;	
}
bool bfs(){
	memset(d,-1,sizeof(d));	
	queue<int> q;
	q.push(S);d[S]=0;cur[S]=head[S];
	while(!q.empty()){
		int u=q.front();q.pop();
		for(int i=head[u];i!=-1;i=edge[i].next){
			int v=edge[i].to;
			if(d[v]==-1&&edge[i].cap){
				d[v]=d[u]+1;
				cur[v]=head[v];
				if(v==T) return true;
				q.push(v);
			}			
		}
	}
	return false;
}
int dfs(int u,int limit){
	if(u==T) return limit;
	int flow=0;
	for(int i=cur[u];i!=-1&&flow<limit;i=edge[i].next){
		cur[u]=i;
		int v=edge[i].to;
		if(d[v]==d[u]+1&&edge[i].cap){
			int delta=dfs(v,min(edge[i].cap,limit-flow));
			if(!delta) d[v]=-1;
			edge[i].cap-=delta;
			edge[i^1].cap+=delta;
			flow+=delta;
		}
	}
	return flow;
}
int dinic(){
	int maxFlow=0,delta;
	while(bfs()){
		while(delta=dfs(S,INF)){
			maxFlow+=delta;
		}
	}
	return maxFlow;  	
}
int main(){
	int s,t;
	cin>>n>>m>>s>>t;
	S=0,T=n+1;
	memset(head,-1,sizeof(head));
	while(m--){
		int a,b,c,d;cin>>a>>b>>c>>d;
		add(a,b,d-c);
		A[a]-=c;A[b]+=c;
	}
	int num=0;
	rep(i,1,n){
		if(A[i]>0) {add(S,i,A[i]),num+=A[i];}
		else if(A[i]<0) {add(i,T,-A[i]);}
	}
	add(t,s,INF);
	if(dinic()<num) puts("No Solution");
	else{
		int res=edge[tot-1].cap;
		S=s,T=t;
		edge[tot-1].cap=edge[tot-2].cap=0;
		cout<<res+dinic()<<endl;
	}
}

AcWing.2190有源汇上下界最小流

#include<bits/stdc++.h>
#define ll long long
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,n,a) for(int i=n;i>=a;i--)
#define endl '\n'
#define mem(a) memset(a,0,sizeof(a))
#define IO ios::sync_with_stdio(false);cin.tie(0);
using namespace std;
const int INF=2147483647;
const int mod=1e9+7;
const int N=50010;
const int M=(N+125003)*2;
int n,m,S,T;
int head[N],d[N],cur[N],A[N],tot;
struct E{
	int to,next,cap;
}edge[M];
void add(int u,int v,int w){
	edge[tot].to=v;
	edge[tot].next=head[u];
	edge[tot].cap=w;
	head[u]=tot++;
	edge[tot].to=u;
	edge[tot].next=head[v];
	edge[tot].cap=0;
	head[v]=tot++;	
}
bool bfs(){
	memset(d,-1,sizeof(d));	
	queue<int> q;
	q.push(S);d[S]=0;cur[S]=head[S];
	while(!q.empty()){
		int u=q.front();q.pop();
		for(int i=head[u];i!=-1;i=edge[i].next){
			int v=edge[i].to;
			if(d[v]==-1&&edge[i].cap){
				d[v]=d[u]+1;
				cur[v]=head[v];
				if(v==T) return true;
				q.push(v);
			}			
		}
	}
	return false;
}
int dfs(int u,int limit){
	if(u==T) return limit;
	int flow=0;
	for(int i=cur[u];i!=-1&&flow<limit;i=edge[i].next){
		cur[u]=i;
		int v=edge[i].to;
		if(d[v]==d[u]+1&&edge[i].cap){
			int delta=dfs(v,min(edge[i].cap,limit-flow));
			if(!delta) d[v]=-1;
			edge[i].cap-=delta;
			edge[i^1].cap+=delta;
			flow+=delta;
		}
	}
	return flow;
}
int dinic(){
	int maxFlow=0,delta;
	while(bfs()){
		while(delta=dfs(S,INF)){
			maxFlow+=delta;
		}
	}
	return maxFlow;  	
}
int main(){
	int s,t;
	cin>>n>>m>>s>>t;
	S=0,T=n+1;
	memset(head,-1,sizeof(head));
	while(m--){
		int a,b,c,d;cin>>a>>b>>c>>d;
		add(a,b,d-c);
		A[a]-=c;A[b]+=c;
	}
	int num=0;
	rep(i,1,n){
		if(A[i]>0) {add(S,i,A[i]),num+=A[i];}
		else if(A[i]<0) {add(i,T,-A[i]);}
	}
	add(t,s,INF);
	if(dinic()<num) puts("No Solution");
	else{
		int res=edge[tot-1].cap;
		S=t,T=s;
		edge[tot-1].cap=edge[tot-2].cap=0;
		cout<<res-dinic()<<endl;
	}
}

AcWing.2234多源汇最大流

#include<bits/stdc++.h>
#define ll long long
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,n,a) for(int i=n;i>=a;i--)
#define endl '\n'
#define mem(a) memset(a,0,sizeof(a))
#define IO ios::sync_with_stdio(false);cin.tie(0);
using namespace std;
const int INF=2147483647;
const int mod=1e9+7;
const int N=10010;
const int M=(N+100005)*2;
int n,m,S,T;
int head[N],d[N],cur[N],A[N],tot;
struct E{
	int to,next,cap;
}edge[M];
void add(int u,int v,int w){
	edge[tot].to=v;
	edge[tot].next=head[u];
	edge[tot].cap=w;
	head[u]=tot++;
	edge[tot].to=u;
	edge[tot].next=head[v];
	edge[tot].cap=0;
	head[v]=tot++;	
}
bool bfs(){
	memset(d,-1,sizeof(d));	
	queue<int> q;
	q.push(S);d[S]=0;cur[S]=head[S];
	while(!q.empty()){
		int u=q.front();q.pop();
		for(int i=head[u];i!=-1;i=edge[i].next){
			int v=edge[i].to;
			if(d[v]==-1&&edge[i].cap){
				d[v]=d[u]+1;
				cur[v]=head[v];
				if(v==T) return true;
				q.push(v);
			}			
		}
	}
	return false;
}
int dfs(int u,int limit){
	if(u==T) return limit;
	int flow=0;
	for(int i=cur[u];i!=-1&&flow<limit;i=edge[i].next){
		cur[u]=i;
		int v=edge[i].to;
		if(d[v]==d[u]+1&&edge[i].cap){
			int delta=dfs(v,min(edge[i].cap,limit-flow));
			if(!delta) d[v]=-1;
			edge[i].cap-=delta;
			edge[i^1].cap+=delta;
			flow+=delta;
		}
	}
	return flow;
}
int dinic(){
	int maxFlow=0,delta;
	while(bfs()){
		while(delta=dfs(S,INF)){
			maxFlow+=delta;
		}
	}
	return maxFlow;  	
}
int main(){
	int sc,tc;
	cin>>n>>m>>sc>>tc;
	S=0,T=n+1;
	memset(head,-1,sizeof(head));
	while(sc--){
		int x;cin>>x;
		add(S,x,INF);
	}
	while(tc--){
		int x;cin>>x;
		add(x,T,INF);
	}
	while(m--){
		int a,b,c;cin>>a>>b>>c;
		add(a,b,c);
	}
	cout<<dinic()<<endl;
}

AcWing.2236 寻找关键边

#include<bits/stdc++.h>
#define ll long long
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,n,a) for(int i=n;i>=a;i--)
#define endl '\n'
#define mem(a) memset(a,0,sizeof(a))
#define IO ios::sync_with_stdio(false);cin.tie(0);
using namespace std;
const int INF=2147483647;
const int mod=1e9+7;
const int N=600;
const int M=(N+10005)*2;
int n,m,S,T;
int head[N],d[N],cur[N],A[N],tot;
struct E{
	int to,next,cap;
}edge[M];
void add(int u,int v,int w){
	edge[tot].to=v;
	edge[tot].next=head[u];
	edge[tot].cap=w;
	head[u]=tot++;
	edge[tot].to=u;
	edge[tot].next=head[v];
	edge[tot].cap=0;
	head[v]=tot++;	
}
bool bfs(){
	memset(d,-1,sizeof(d));	
	queue<int> q;
	q.push(S);d[S]=0;cur[S]=head[S];
	while(!q.empty()){
		int u=q.front();q.pop();
		for(int i=head[u];i!=-1;i=edge[i].next){
			int v=edge[i].to;
			if(d[v]==-1&&edge[i].cap){
				d[v]=d[u]+1;
				cur[v]=head[v];
				if(v==T) return true;
				q.push(v);
			}			
		}
	}
	return false;
}
int dfs(int u,int limit){
	if(u==T) return limit;
	int flow=0;
	for(int i=cur[u];i!=-1&&flow<limit;i=edge[i].next){
		cur[u]=i;
		int v=edge[i].to;
		if(d[v]==d[u]+1&&edge[i].cap){
			int delta=dfs(v,min(edge[i].cap,limit-flow));
			if(!delta) d[v]=-1;
			edge[i].cap-=delta;
			edge[i^1].cap+=delta;
			flow+=delta;
		}
	}
	return flow;
}
int dinic(){
	int maxFlow=0,delta;
	while(bfs()){
		while(delta=dfs(S,INF)){
			maxFlow+=delta;
		}
	}
	return maxFlow;  	
}
bool vis_s[N],vis_t[N];
void dfss(int u,bool st[],int t){
	st[u]=true;
	for(int i=head[u];i!=-1;i=edge[i].next){
		int j=i^t,v=edge[i].to;
		if(edge[j].cap&&!st[v]){
			dfss(v,st,t);
		}
	}
}
int main(){
	cin>>n>>m;
	S=0,T=n-1;
	memset(head,-1,sizeof(head));
	for(int i=0;i<m;i++){
		int a,b,c;cin>>a>>b>>c;
		add(a,b,c);
	}
	dinic();
	dfss(S,vis_s,0);
	dfss(T,vis_t,1);
	int res=0;
	for(int i=0;i<m*2;i+=2){
		if(!edge[i].cap&&vis_s[edge[i^1].to]&&vis_t[edge[i].to]){
			res++;
		}
	}
	cout<<res<<endl;
}
Anonytt
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
网络流.pptx
07-17
网络流的应用，需会最简单的网络流模板 二分图基本定理 二分图多重匹配 最大权闭合子图 最小割 费用流 有上下界的网络流
图论 | 网络流的基本概念
最新发布
qq_45931691的博客
12-21 2548
只需要再证明最大流大于等于最小割，就可以推出最大流等于最小割。是最大流，而它的残留网络存在增广路，则有。将 EK 算法中的 BFS 换成 SPFA。残留网络定义：一个可行流流网络。不是最大流，与原假设矛盾。最小割一定某个割，即。
【图论】网络流总结
weixin_30905981的博客
07-30 146
【图论】网络流总结 最大流部分 网络流题目的关键：看出是网络流而且确定正确的模型 最大流算法：用来解决从源点s到汇点t，整个网络最多能输送多少流量的题目 模板： #include <cstdio> #include <cstring> #include <queue> #include <algorithm&g...
图论 —— 网络流 —— 基本概念与建模技巧
Alex_McAvoy的博客
10-05 8413
【基本概念】 1.网络流 给定一个有向图 G=(V,E)，在这个图中： 有唯一的一个源点 S（入度为 0，出发点） 有唯一的一个汇点 T（出度为 0，结束点） 图中的每条弧（u,v）都有一非负容量 c(u,v) 此时称图 G 为网络流图（容量网络），记为：G=(V,E,c) 简单来说，图就是一种管道，管道有最大通过流量的限制，图中的边权就是容量 2.可行流 对于一个网络流图 G=(...
图论——网络流
fujang的博客
12-26 1023
网络流 最大流知识点梳理 流网络，不考虑反向边，可以存在环，有向图。 可行流，不考虑反向边。 （1）两个条件：容量限制，流量守恒。 （2）可行流的流量指从源点流出的流量-流入源点的流量。 （3）最大流是指最大可行流。 残留网络，考虑反向边，和可行流一一对应，是原图中边数的二倍。其中正向的边表示可以增加的流量，反向的边表示可以退回去的流量。 残留网络的可行流f’+原图的可行流f=原题的另一个可行流。 （1）|f’+f| = |f|+|f’| （2）|f’|可能是负数 增广路径，从源点出发，沿着容量大于0的
最大流_最大流模板_
09-30
最大流问题是一个经典的图论问题，它在计算机科学和网络流理论中占有重要地位，尤其在运筹学、算法设计和优化等领域应用广泛。在信息学奥林匹克竞赛中，选手们经常需要解决这类问题来求解网络中的最大传输能力。本文...
ACM图论数据结构常见模板
09-26
网络流 38 最大流 && 最小割 38 费用流 46 一般数据结构 49 ST Table 49 树状数组 51 树链剖分 52 平衡二叉树 56 Splay 56 数学 64 结论&&推论 64 快速乘法 65 逆元 66 [1, n]素数个数 66 pell方程 68 秦九韶算法 68...
ACM之网络流
06-11
网络流是图论中的一个重要概念，它在计算机科学，尤其是算法设计和理论计算领域有着广泛的应用，特别是在运筹学、优化问题以及网络资源分配中。本资料“ACM之网络流”显然关注的是如何利用网络流算法解决实际问题，...
C++关于图论入门的课件
09-15
在C++中，理解图论有助于解决许多复杂问题，如路径搜索、网络流、最短路径等。以下是对图论及其在C++中实现的基础知识的详细解释： **图的概念** 图是一个二元组 (V, E)，其中V是非空集合，代表顶点或节点，E是V...
图论与网络流理论.pdf（高清版）
03-02
图论与网络流理论.pdf（高清版）
图论-网络流①-什么是网络流
KonnyWen的博客
02-16 687
图论-网络流 参考文献： https://www.cnblogs.com/DuskOB/p/11216861.html https://blog.csdn.net/yjr3426619/article/details/82808303 https://blog.csdn.net/lym940928/article/details/90209172 https://baike.baidu.com...
图论网络流
Shelter
01-01 1388
DFS dfs树 无向图：只有树边和非树边 每条非树边对应一个环：判仙人掌 对于一个联通块忽略所有非树边进行一些操作：证明，构造 有向图：树边、回向边、前向边、同层之间的边 只有树边和前向边会从dfs序小的指向大的：Dominator Tree dfs序 无向图：dfs树上的每个子树对应dfs序的一个区间 主要是在树上使用 点/边...
图论网络流相关
新的开始...
01-15 248
1. 所有顶点对的最短路径 动态规划解法一：设 dp[i][j][m] 为顶点 i ~ j 中间最多经过 m 条边时的最短路径，不难得出存在下面状态转移方程 dp[i][j][m] = min{dp[i][k][m-1] + w[k][j]}，其中 1&amp;amp;amp;amp;amp;amp;lt;=i&amp;amp;amp;amp;amp;amp;lt;=n。假设原图不存在负权值回路，则对于包含 n 个点的图，任意顶点对 (i, j) 最短路径（简单路径）中间经过的边数最多为 n
图论（网络流的基本概念）
qq_51963033的博客
02-03 759
流网络（可以有环的有向图） 流网络有两个特殊的点：源点S，汇点T。 流网络中每条边都有一个属性：流网络的容量：相当于水管的流量的限制。 源点有无穷多的流量，汇点有无穷多的容量。 G=（V,E) 注：假设不存在反向边 当然对于有反向边的情况，也可以在反向边上加一个点，这样就相当于没有反向边了 对于每一个流网络我们考虑每一个可行流（f）：指定每一条边的流量（需要满足容量限制 0<=f(u,v)；流量守恒：对于任意X属于V不包括S,T，所有流量之和等于流出去之和。 流量值：流出源点流量-流
AcWing 2172 最大流模板
QAQ
03-30 97
题目链接 代码 dinic算法 据说可以处理10410^4104 到 10510^5105的数据 #include <bits/stdc++.h> using namespace std; using ll = long long; const int N = 1e4 + 10, M = 2e5 + 10, inf = 1e8; int n, m, S, T; int h[N], e[M], f[M], ne[M], idx; int q[N], d[N], cur[N]; void a
图论 —— 网络流
Alex_McAvoy的博客
04-06 3268
【概述】 网络流是一个适用范围极广的模型，相关的算法也很多，大体分为最大流、最小割、费用流三类。 对于网络流类型的题来说，一般根据题意，分析后建出图后，套用相关模版，即可解决问题。 关于网络流的基本概念与建模技巧：点击这里 【算法】 1.最大流算法 求最大流算法分为两类，一种是增广路算法，一种是预留推进算法。 增广路算法，常用的有时间复杂度 O(n*m*m) 的 FF 算法、EK 算...
图论笔记：网络流问题
weixin_50549897的博客
07-31 394
图论笔记：网络流问题前言一、最大流最大流问题：Ford-Fullkerson方法Edmonds-Karp算法（EK）：最大流建模：最小割问题：最小费用最大流：最大流问题变式：变式一：多源点多汇点变式二：无向图变式三：顶点上也有容量限制的情况 前言 一、最大流 最大流问题：Ford-Fullkerson方法 Edmonds-Karp算法（EK）： 由于适用规模小所以用邻接矩阵存图 １.找到一条增广路２.找到瓶颈正向路径减少ｆｌｏｗ，反向路径增加ｆｌｏｗ３.直到找不到增广路 #include<b.
C++ 【蓝书】网络流问题（网络流基础概念+三个算法+做题时的选择+模板整合）【网络流从入门到放弃】
超逸の学习技术博客
08-10 1454
明天写。。。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值