网络流算法//最大流（洛谷3376）//EK算法//dinic算法//最小（大）费用最大流（待续）

最新推荐文章于 2023-09-20 09:48:46 发布
最新推荐文章于 2023-09-20 09:48:46 发布
阅读量456 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/castomere/article/details/98781496
版权

目录

最大流流算法

（EK算法）

时间复杂度 O(V*（E^2）)

 

Dinic算法

时间复杂度O(（V ^ 2） * E)

在洛谷题解中看到了一句很有启发的话：网络流善于解决各种有要求的匹配

联想到题目是匹配问题，且满足网络流要求的数据范围，可以尝试网络流

 

V是点的数目，E是边的数目

最大流流算法

（EK算法）

时间复杂度 O(V*（E^2）)

定义：

我们有一个 源点（只有流出量） 和 汇点（只有流入量）

每条边有一个 流量 和 容量，流量最初为0，容量是题目告知我们的，我们要求的是 在所有边的 流量 <= 容量 && 每个点流入量 = 流出量 时，流入汇点的最大流是多少。


首先我们需要知道残留网络：

残留网络就是反向图的流量，我们正向遍历一个图，会走一条路径到汇点。

一条路径的   增广路 = min（经过的每条边的 {容量 - 当前流量} ）

但是我们这条边可能是反向的流，所以

  • 正向边的容量 -= 增广路
  • 反向边容量 += 增广路

找到增广路，我们就 flow += 增广路

当找不到增广路就结束了这个算法。

因为看了vector建图和链式前向星建图的效率和空间差异，就手动改了一下模板，不用常用的mp[][] 数组标记，练习一下链式前向星。不太懂的，这里看看https://blog.csdn.net/castomere/article/details/80426485

 

最大流最小割定理：

割 是 一些边被砍断，让S（源点） 和 T（汇点）不连通的边，这些边的容量sum就是 割 的容量，最小割，就是让割的容量最小，想像最大流时，一些边被流填满，那么 最大流 就是 最小割的容量

 

洛谷3376

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <iostream>
#include <cmath>
#include <map>
#include <queue>
#include <algorithm>
#include <set>
#include <vector>
#include <stack>
#define Clear( x , y ) memset( x , y , sizeof(x) );
#define Qcin() std::ios::sync_with_stdio(false);
using namespace std;
typedef long long LL;
const int Maxn = 1e4 + 7;
const int MaxN = 2e5 + 7;
const int Inf = 1e9 + 7;
// O{V * E ^ 2}
/*
源点 st , 汇点 ed
*/
int N , M;
int st , ed;

int cnt;
struct edge{
	int Next;//下一条边的存储下标
	int to;//这条边的终点
	int w;//边权
};
edge Edge[MaxN];
int head[Maxn];//以 i 为起点的第一条边的标记
void AddEdge(int u , int v , int w){
	Edge[++cnt].Next = head[u];
	Edge[cnt].w = w;
	Edge[cnt].to = v;
	head[u] = cnt;
}

int pre[Maxn][2];
int Flow;
int flow[Maxn];
queue <int> que;
bool Bfs(){
	while(!que.empty())	que.pop();
	for(int i = 0 ; i <= N ; i++) pre[i][0] = pre[i][1] = -1;
	flow[st] = Inf;
	int q;
	que.push(st);
	while(!que.empty()){
		q = que.front(); que.pop();
		if(q == ed)	break;
		for(int i = head[q] ; ~i ; i = Edge[i].Next){
			int nq = Edge[i].to;
			if(nq != st && Edge[i].w && pre[nq][0] == -1){//下个点nq不是st,且边权>0,nq没被遍历过
				pre[nq][0] = i;//记录前一条边的编号
				pre[nq][1] = q;//记录nq前一个点q
				flow[nq] = min(Edge[i].w , flow[q]);//到nq路径上取min边权
				que.push(nq);
			}
		}
	}
	if(pre[ed][0] == -1)	return false;
	return true;
}

void MaxFlow(){
	int add , pl , fa , p;
	while(Bfs()){
		add = flow[ed];
		p = ed;
		while(p != st){
			pl = pre[p][0];//p上一条边的编号
			p = pre[p][1];//p变为它的上一个点
			Edge[pl].w -= add;
			Edge[pl^1].w += add;
		}
		Flow += add;
	}
	printf("%d\n",Flow);
	return;
}

void init(){
	for(int i = 0 ; i <= N ; i++)	head[i] = -1;
	cnt = -1;//从-1 开始 可以用 x ^ 1 来关联正反边
	return;
}

int main()
{
	scanf(" %d %d %d %d",&N,&M,&st,&ed);
	init();
	for(int i = 1 ; i <= M ; i++){
		int u , v , c , ct1 , ct2;	scanf(" %d %d %d",&u,&v,&c);
		AddEdge(u , v , c);
		AddEdge(v , u , 0);
	}
	MaxFlow();
	return 0;
}

 

Dinic算法

EK通常解决10^3 –10^4规模的网络 
而dinic能解决10^4–10^5的网络

时间复杂度O(（V ^ 2） * E)

(真的快了不是一点，这一道题，Dinic是EK的 1/4 时间)

算法流程：

  • 在存在增广路的边上建立分层图，如果汇点不在存在增广路的分层图上，那么就不存在新的增广路，结束算法
  • 当存在汇点增广路，执行Dfs操作，在分层图中寻找增广路，增广路径从 u 到 v ， 当且仅当dep[v] = dep[u] + 1
  • 找到增广路，Dfs回溯时减去增广路，一个节点可能减了多次增广路。

洛谷3376

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <iostream>
#include <cmath>
#include <map>
#include <queue>
#include <algorithm>
#include <set>
#include <vector>
#include <stack>
#define Clear( x , y ) memset( x , y , sizeof(x) );
#define Qcin() std::ios::sync_with_stdio(false);
using namespace std;
typedef long long LL;
const int Maxn = 1e4 + 7;
const int MaxN = 2e5 + 7;
const int Inf = 1e9 + 7;

int N , M;
int st , ed;
int Flow;

int cnt;
struct edge{
	int Next;
	int to;
	int w;
};
edge Edge[MaxN];
int head[Maxn];
void AddEdge(int u , int v , int w){
	Edge[++cnt].Next = head[u];
	Edge[cnt].w = w;
	Edge[cnt].to = v;
	head[u] = cnt;
}

int dep[Maxn];
queue <int> que;
bool Bfs(){
	for(int i = 1 ; i <= N ; ++i)	dep[i] = 0;
	while(!que.empty())	que.pop();
	dep[st] = 1;
	que.push(st);
	int q , v;
	while(!que.empty()){
		q = que.front(); que.pop();
		for(int i = head[q] ; ~i ; i = Edge[i].Next){
			v = Edge[i].to;
			if(Edge[i].w && !dep[v]){
				que.push(v);
				dep[v] = dep[q] + 1;
				if(v == ed)	return true;
			}
		}
	}
	return false;
}

int Dfs(int x , int flow){
	if(x == ed)	return flow;
	int res = flow , add;
	for(int i = head[x] ; ~i && res ; i = Edge[i].Next){
		int v = Edge[i].to;
		if(Edge[i].w && dep[v] == dep[x] + 1){
			add = Dfs(v , min(res , Edge[i].w));
			if(!add)	dep[v] = 0;
			Edge[i].w -= add;
			Edge[i^1].w += add;
			res -= add;
		}
	}
	return flow - res;
}

void Dinic(){
	int flow;
	while(Bfs()){
		while(flow = Dfs(st , Inf)){
			Flow += flow;
		}
	}
	printf("%d\n",Flow);
}
void init(){
	for(int i = 1 ; i <= N ; i++)	head[i] = -1;
	Flow = 0;
	cnt = -1;
}


int main()
{
	scanf(" %d %d %d %d",&N,&M,&st,&ed);
	init();
	for(int i = 1 ; i <= M ; i++){
		int u , v , c; scanf(" %d %d %d",&u,&v,&c);
		AddEdge(u , v , c);
		AddEdge(v , u , 0);
	}
	Dinic();
}

 

洛谷 P2763

我们已经学会了基础的最大流，那么就需要继续研究最小费用最大流 和 最大费用最大流

最小费用最大流

定义：

在最大流相同的情况下，我们要求花费最小的费用。

我们发现它类似最短路的条件，我们把价格所以就在求解增广路的过程中加一个 条件来筛选，即选择最短路进行增广。

分析：

因为dijkstra是在一个点的连边中 选最小的边权进行拓展，就像它不能处理带负权的最短路一样，所以我们用SPFA维护 反向边的负权流量。其他的同步最大流算法。

洛谷P3381

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <iostream>
#include <cmath>
#include <map>
#include <queue>
#include <algorithm>
#include <set>
#include <vector>
#include <stack>
#define Clear( x , y ) memset( x , y , sizeof(x) );
#define Qcin() std::ios::sync_with_stdio(false);
using namespace std;
typedef long long LL;
const int Maxn = 1e4 + 7;
const int MaxN = 2e5 + 7;
const int Inf = 1e9 + 7;

int N , M;
int st , ed;
int Flow , MinCost;

int cnt;
struct edge{
	int Next;
	int to;
	int w;
	int c;
};
edge Edge[MaxN];
int head[Maxn];
void AddEdge(int u , int v , int w , int cost){
	Edge[++cnt].Next = head[u];
	Edge[cnt].w = w;
	Edge[cnt].to = v;
	Edge[cnt].c = cost;
	head[u] = cnt;
}

int dis[Maxn] , pre[Maxn] , last[Maxn] ,  flow[Maxn];
bool vis[Maxn];
//last[i] 前一条边 , pre[i] 前一个点
queue <int> que;
bool Spfa(){
	for(int i = 1 ; i <= N ; ++i){
		dis[i] = flow[i] = Inf;
		vis[i] = false;
	}
	int q , v , w , cost;
	pre[ed] = -1;
	vis[st] = 1; dis[st] = 0;
	que.push(st);
	while(!que.empty()){
		q = que.front(); que.pop();
		vis[q] = 0;
		for(int i = head[q] ; ~i ; i = Edge[i].Next){
			v = Edge[i].to;
			w = Edge[i].w;
			cost = Edge[i].c;
			if(w > 0 && dis[v] > dis[q] + cost){
				dis[v] = dis[q] + cost;
				last[v] = i;
				pre[v] = q;
				flow[v] = min(flow[q] , w);
				if(!vis[v]){
					vis[v] = 1;
					que.push(v);
				}
			}
		}
	}
	if(pre[ed] != -1)	return true;
	return false;
}

void MinCostFlow(){
	while(Spfa()){
		int p = ed;
		Flow += flow[ed];
		MinCost += flow[ed] * dis[ed];
		while(p != st){
			Edge[last[p]].w -= flow[ed];
			Edge[last[p]^1].w += flow[ed];
			p = pre[p];
		}
	}
	printf("%d %d\n",Flow , MinCost);
}

void init(){
	for(int i = 0 ; i <= N ; i++){
		head[i] = -1;
	}
	cnt = -1;
	Flow = MinCost = 0;
}

int main()
{
	scanf(" %d %d %d %d",&N ,&M ,&st ,&ed);
	init();
	for(int i = 1 ; i <= M ; i++){
		int u , v , w , cost; scanf(" %d %d %d %d",&u,&v,&w,&cost);
		AddEdge(u , v , w , cost);
		AddEdge(v , u , 0 , -cost);
	}
	MinCostFlow();
}

 

最大费用最大流

 

先贴个板子

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <iostream>
#include <cmath>
#include <map>
#include <queue>
#include <algorithm>
#include <set>
#include <vector>
#include <stack>
#define Clear( x , y ) memset( x , y , sizeof(x) );
#define Qcin() std::ios::sync_with_stdio(false);
using namespace std;
typedef long long LL;
const int Maxn = 1e4 + 7;
const int MaxN = 2e5 + 7;
const int Inf = 1e9 + 7;

int N , M;
int st , ed;
int Flow , MaxCost;

int cnt;
struct edge{
	int pre;
	int Next;
	int to;
	int w;
	int c;
};
edge Edge[MaxN];
int head[Maxn];
void AddEdge(int u , int v , int w , int cost){
	Edge[++cnt].Next = head[u];
	Edge[cnt].pre = u;
	Edge[cnt].w = w;
	Edge[cnt].to = v;
	Edge[cnt].c = cost;
	head[u] = cnt;
}

int dis[Maxn] , preWay[Maxn] ,  flow[Maxn];
bool vis[Maxn];
//last[i] 前一条边 , pre[i] 前一个点
queue <int> que;
bool Spfa(){
	for(int i = 1 ; i <= N ; ++i){
		dis[i] = -Inf;
		preWay[i] = -1;
		vis[i] = false;
	}
	int q , v , w , cost;
	vis[st] = 1; dis[st] = 0;
	que.push(st);
	while(!que.empty()){
		q = que.front(); que.pop();
		vis[q] = 0;
		for(int i = head[q] ; ~i ; i = Edge[i].Next){
			v = Edge[i].to;
			w = Edge[i].w;
			cost = Edge[i].c;
			if(w > 0 && dis[v] < dis[q] + cost){
				dis[v] = dis[q] + cost;
				preWay[v] = i;
				if(!vis[v]){
					vis[v] = 1;
					que.push(v);
				}
			}
		}
	}
	if(preWay[ed] != -1)	return true;
	return false;
}

void MaxCostFlow(){
	while(Spfa()){
		int tmpFlow = Inf;
		for(int i = preWay[ed] ; ~i ; i = preWay[Edge[i].pre] ){
			if(tmpFlow > Edge[i].w){
				tmpFlow = Edge[i].w;
			}
		}
		for(int i = preWay[ed] ; ~i ; i = preWay[Edge[i].pre]){
			Edge[i].w -= tmpFlow;
			Edge[i^1].w += tmpFlow;
			MaxCost += tmpFlow * Edge[i].c;
		}
		Flow += tmpFlow;
	}
	printf("%d %d\n",Flow , MaxCost);
}

void init(){
	for(int i = 0 ; i <= N ; i++){
		head[i] = -1;
	}
	cnt = -1;
	Flow = MaxCost = 0;
}

int main()
{
	scanf(" %d %d %d %d",&N ,&M ,&st ,&ed);
	init();
	for(int i = 1 ; i <= M ; i++){
		int u , v , w , cost; scanf(" %d %d %d %d",&u,&v,&w,&cost);
		AddEdge(u , v , w , cost);
		AddEdge(v , u , 0 , -cost);
	}
	MaxCostFlow();
}

 

castomere
关注
专栏目录
[洛谷P3376题解]网络流（最大流）的实现算法讲解与代码
qq_16204149的博客
07-20 636
[洛谷P3376题解]网络流（最大流）的实现算法讲解与代码 定义 对于给定的一个网络，有向图中每个的边权表示可以通过的最大流量。假设出发点S水流无限大，求水流到终点T后的最大流量。 起点我们一般称为源点，终点一般称为汇点 内容前置 1.增广路 ​ 在一个网络从源点S到汇点T的一条各边剩余流量都大于0(还能让水流通过,没有堵住)的一条路。 2.分层 ​ 预处理出源点到每个点的距离(每次寻找增广路都要,因为以前原本能走的路可能因为水灌满了,导致不能走了).作用是保证只往更远的地方放水,避免兜圈子或者是没事就走回
P3381 【模板】最小费用最大流
bjfu170203101的博客
07-12 390
时间复杂度为O(N*E*k)，其中K为最大流值。但时间上的期望时间复杂度为：O(A*E*K)，其中A为所有顶点进队列的平均次数，可以证明A一般小于等于2。 玄学复杂度。。 把EK求最大流的bfs改成spfa 就能求zui'xiao #include<bits/stdc++.h> using namespace std; const int MAXN = 5001; const int MAXM = 50001; int n, m, s, t, cnt = 1; int maxflow,
【模板】网络最大流
weixin_34250709的博客
03-04 178
https://www.luogu.org/problem/show?pid=3376 题目描述 如题，给出一个网络图，以及其源点和汇点，求出其网络最大流。 输入输出格式 输入格式： 第一行包含四个正整数N、M、S、T，分别表示点的个数、有向边的个数、源点序号、汇点序号。 接下来M行每行包含三个正整数ui、vi、wi，表示第i条有向边从ui出发，到达vi，边权为wi（即该边最大流...
最小费用最大流问题
weixin_34206899的博客
08-18 123
最小费用最大流就是在原来求最大流的基础上，假设每条边还有一个单位流量所需要的费用，因为最小费用的出现，原本的平行边变得有意义，并且允许反向增广，基本上就是将原本BFS改为进行一次BellmanFord算法寻找最短路径，只要初始流是该流量下的最小费用可行流，每次增广后的新流都是新流量下的最小费用流。下面POJ2135的题解： 题意： 从起点出发，走到终点再回到起点...
数据结构与算法之最小费用最大流算法
weixin_47225948的博客
09-20 1455
数据结构与算法之最小费用最大流算法
Dinic.rar_Dinif2.m_dinic_最大流_最大流算法_最大网络流
07-15
相比于其他最大流算法，如Ford-Fulkerson方法，Dinic算法在最坏情况下的时间复杂度可以达到O(V^2 * E)，其中V是节点数量，E是边的数量，这在很多情况下是可接受的。 总之，Dinic算法是一种强大的工具，用于解决网络...
C/C++，图算法-Dinic最大流量算法
最新发布
05-14
C/C++，图算法——Dinic最大流量算法
最大网络流Dinic算法
09-01
总结起来，Dinic算法是解决最大网络流问题的一种高效方法，通过层次结构和增广路径的概念，能够在保证正确性的前提下，实现较好的运行效率。在实际应用中，它可以用于解决资源分配、调度、通信网络流量规划等问题。
网络流最大流Dinic算法代码
10-16
最大流的Dinic算法，时间复杂度O(EV^2),代码简单而高效
Python使用遗传算法解决最大流问题
09-20
在计算机科学领域，解决网络中的最大流问题是图论中的一个重要问题。最大流问题是指在有向图中，从源点到汇点的最大流量是多少。为了解决这一问题，有许多算法被提出，如Ford-Fulkerson方法、Edmonds-Karp算法、...
最小费用最大流的实现之Dijkstra+Ford-fulksonff算法
hzl877243276的专栏
12-07 1999
<br /> <br />文章写的很详细，对于学习最小费用最大流的求解算法有很大的启发作用<br />原帖地址附上http://www.cppblog.com/guojingjia2006/archive/2009/11/12/57905.html还要感谢博主啊最小费用最大流 修改的dijkstra + Ford-Fulksonff算法<br />修改的dijkstra其实和Johnson算法的思想是一致的。<br /> <br />一个求最小费用最大流的朴素算法是这样的：<br />1 求最小费用增广路<
图论--最小费用最大流（MCMF）
玫葵之蝶
08-12 503
以下为提高+难度。关于这个算法我不多做阐述，因为我说的肯定没有lrj大神说得好，大家可以看他的书–《算法竞赛入门经典》，那里有详细描述。 到了这种难度，极其建议大家去抄抄代码，过一遍手，比什么都强。 我也是这一遍抄完了，才感觉这两天的网络流明白了。下来就是代码。 code：//洛谷 P3381 【模板】最小费用最大流 #include<bits/stdc++.h> #define ll lon
mysql最小费用最大流问题_最小费用最大流问题(示例代码)
weixin_42501270的博客
02-03 427
费用流假设每条边除了有一个容量限制外，还有一个单位流量所需的费用(cost)。该网络中花费最小的最大流称为最小费用最大流，即总流量最大的情况下，总费用最小的流。和 Edmonds-Karp 算法类似，但每次用 Bellman-Ford 算法而非 BFS 找增广路。只要初始流是该流量下的最小费用可行流，每次增广后的新流都是新流量下的最小费用流。Bellman-Ford版如何用优先队列代替Bellma...
最小费用最大流问题与算法实现（Bellman-Ford、SPFA、Dijkstra）
热门推荐
不积跬步无以至千里
05-14 6万+
Bellman-Ford、SPFA、改进的Dijkstra三种算法解决最小费用最大流问题以及相关代码的实现。
【图论】最大流之EK算法与Dinic算法及最小费用最大流
Mankind的博客
03-20 2455
最大流： 给出一张网络图，并指定源点和终点，每条边都有它的容量，起点有着无限的流量，求从源点到经过的所有路径的最终到达汇点的最大流量和。对于同一个节点，流入的流量之和和流出的流量之和相同，即假如结点1有12流量流入结点2，结点2分别有8流量流入结点3,4流量流入结点4，这种情况是可以的。  EK算法： 而EK算法反复寻找源点s到汇点t之间的增广路径，若有，找出增广路径上每一段[容量-
洛谷 P3376 【模板】网络最大流 （EK/Dinic）
wineandchord
07-15 112
网络流的模板题。 // EK algorithm 复杂度 O(NM^2) // 整体思路是通过不断地bfs找增广路径，然后通过增广路径扩充最大流 #include<iostream> #include<cstdio> #include<cstring> #include<queue> #define MAXN 250 #define MAXM 10010 #define INF 0x3f3f3f3f using namespace std; typedef l
[hdu3549]Flow Problem(最大流模板题)
weixin_30340819的博客
11-23 92
解题关键：使用的挑战程序设计竞赛上的模板，第一道网络流题目，效率比较低，且用不习惯的vector来建图。 看到网上其他人说此题有重边，需要注意下，此问题只在邻接矩阵建图时会出问题，邻接表不会存在的，也体现了邻接表的优越性？ edge结构体的第三个变量为from的下标。 模板一： #include<bits/stdc++.h> #define MAX_V 17 #defi...
mysql最小费用最大流问题_最小费用最大流
weixin_28523493的博客
02-08 171
最小费用最大流修改的dijkstra+Ford-Fulksonff算法修改的dijkstra其实和Johnson算法的思想是一致的。一个求最小费用最大流的朴素算法是这样的：1求最小费用增广路2判断是否存在增广路，否的话算法终止。3增加增广路上边的流量4在增广路上添加必要的逆向负权边5goto1因为负权边的存在，求最小费用增广路就不可以用dijkstra算法。当然，我们可以用bellman-for...
图论--网络流--最大流 洛谷P4722（hlpp）
日拱一卒,功不唐捐
11-10 2651
题目描述 给定nn个点，mm条有向边，给定每条边的容量，求从点ss到点tt的最大流。 输入格式 第一行包含四个正整数nn、mm、ss、tt，用空格分隔，分别表示点的个数、有向边的个数、源点序号、汇点序号。 接下来mm行每行包含三个正整数u_iui​、v_ivi​、c_ici​，用空格分隔，表示第ii条有向边从u_iui​出发，到达v_ivi​，容量为c_ici​ 输出格式 ...
C/C++ 算法代码库：图论与网络流
- **最大流**：在网络流问题中找到从源点到汇点的最大流量，如Dinic算法（O(V^2*E)）和HLPP算法（O(V^3)）。 - **最小费用流**：同时考虑流量和费用，寻找最小总费用的最大流，有O(V*E*F)和O(V^2*F)的实现。 - **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值