最大流模板

最新推荐文章于 2021-07-28 10:37:40 发布
最新推荐文章于 2021-07-28 10:37:40 发布
阅读量295 收藏 1
点赞数 2
分类专栏： 代码 模板 最大流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41199327/article/details/81901956
版权
代码 同时被 3 个专栏收录
75 篇文章 1 订阅
订阅专栏
模板
3 篇文章 0 订阅
订阅专栏
最大流
3 篇文章 0 订阅
订阅专栏

最近学习了最大流虽然学的一般都是会简单的使用，一下是我用过的几个模板

模板一sap：

#include <bits/stdc++.h>
/*
用maze来存图
*/
typedef long long ll;
using namespace std;
const int MAXN=1100;
int maze[MAXN][MAXN];
int gap[MAXN],dis[MAXN],pre[MAXN],cur[MAXN];
int sap(int start,int End,int nodenum) {
	memset(cur,0,sizeof(cur));
	memset(dis,0,sizeof(dis));
	memset(gap,0,sizeof(gap));
	int u=pre[start]=start,maxflow=0,aug=-1;
	gap[0]=nodenum;
	while(dis[start]<nodenum) {
loop:
		for(int v=cur[u]; v<nodenum; v++)
			if(maze[u][v]&&dis[u]==dis[v]+1) {
				if(aug==-1||aug>maze[u][v])
					aug=maze[u][v];
				pre[v]=u;
				u=cur[u]=v;
				if(v==End) {
					maxflow+=aug;
					for(u=pre[u]; v!=start; v=u,u=pre[u]) {
						maze[u][v]-=aug;
						maze[v][u]+=aug;
					}
					aug=-1;
				}
				goto loop;
			}
		int mindis=nodenum-1;
		for(int v=0; v<nodenum; v++)
			if(maze[u][v]&&mindis>dis[v]) {
				cur[u]=v;
				mindis=dis[v];
			}

		if((--gap[dis[u]])==0) break;
		gap[dis[u]=mindis+1]++;
		u=pre[u];
	}
	return maxflow;
}

模板二  ISAP+bfs 初始化 + 栈优化：

#include <bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
#define MST(a,b) memset(a,b,sizeof(a))
typedef long long ll;
const ll mod=1e4;
const int L=26,maxn=2e3+10;
int n,m,k,T;
struct Edge {
	int to,next,cap,flow;//cap想当与帽子
} edge[maxn];
int tol,head[maxn],gap[maxn],dep[maxn],S[maxn],cur[maxn];
void init() {
	tol=0,MST(head,-1);
}
void addedge(int u,int v,int w,int rw=0) { //如果需要两边同时键边的话传入(u,v,w,w),因为用数组存的时候默认对边是0,；
	edge[tol].to=v;
	edge[tol].cap=w;
	edge[tol].next=head[u];
	edge[tol].flow=0;
	head[u]=tol++;
	edge[tol].to=u;
	edge[tol].cap=rw;
	edge[tol].next=head[v];
	edge[tol].flow=0;
	head[v]=tol++;
}
int Q[maxn];
void bfs(int st,int en) {
	MST(dep,-1),MST(gap,0);
	gap[0]=1;
	int front=0,rear=0;
	dep[en]=0,Q[rear++]=en;
	while(front!=rear) {
		int u=Q[front++];
		for(int i=head[u]; i!=-1; i=edge[i].next) {
			int v=edge[i].to;
			if(dep[v]!=-1) continue;
			Q[rear++]=v;
			dep[v]=dep[u]+1;
			gap[dep[v]]++;
		}
	}
}
int sap(int st,int en,int N) {
	bfs(st,en);
	memcpy(cur,head,sizeof(head));
	int top=0,u=st,ans=0;
	while(dep[st]<N) {
		if(u==en) {
			int Min=INF,inser;
			for(int i=0; i<top; i++)
				if(Min>edge[S[i]].cap-edge[S[i]].flow)
					Min=edge[S[i]].cap-edge[S[i]].flow,inser=i;
			for(int i=0; i<top; i++)
				edge[S[i]].flow+=Min,edge[S[i]^1].flow-=Min;
			ans+=Min,top=inser,u=edge[S[top]^1].to;
			continue;
		}
		bool flag=false;
		int v;
		for(int i=cur[u]; i!=-1; i=edge[i].next) {
			v=edge[i].to;
			if(edge[i].cap-edge[i].flow&&dep[v]+1==dep[u]) {
				flag=true,cur[u]=i;
				break;
			}
		}
		if(flag) {
			S[top++]=cur[u];
			u=v;
			continue;
		}
		int Min=N;
		for(int i=head[u]; i!=-1; i=edge[i].next)
			if(edge[i].cap-edge[i].flow&&dep[edge[i].to]<Min)
				Min=dep[edge[i].to],cur[u]=i;
		gap[dep[u]]--;
		if(!gap[dep[u]]) return ans;
		dep[u]=Min+1,gap[dep[u]]++;
		if(u!=st) u=edge[S[--top]^1].to;
	}
	return ans;
}

模板三 裸最大流：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN=1100;
const int INF=0x3f3f3f3f;
int g[MAXN][MAXN];//原图的流量
int flow[MAXN][MAXN];//最后求得最大流的流量
int path[MAXN];
int a[MAXN];
int start,End,m;
int n;//顶点数，编号1~n
const int MAXM=1550;
int x[MAXM],y[MAXM];
int Max_Flow(){
    queue<int >q;
    memset(flow,0,sizeof(flow));
    int maxflow=0;
    while(1){
        memset(a,0,sizeof(a));
        a[start]=INF;
        while(!q.empty())q.pop();
        q.push(start);
        while(!q.empty()){
            int u=q.front();q.pop();
            //if(u==End)break;
            for(int v=1;v<=n;v++){
                if(!a[v]&&flow[u][v]<g[u][v]){
                    path[v]=u;
                    a[v]=min(a[u],g[u][v]-flow[u][v]);
                    q.push(v);
                }
            }
        }
        if(a[End]==0) break;
        for(int u=End;u!=start;u=path[u]){
            flow[path[u]][u]+=a[End];
            flow[u][path[u]]-=a[End];
        }
        maxflow+=a[End];
    }


    return maxflow;
}

int main(){
    int t;
    scanf("%d",&t);
    int cas=1,cost;
    while(t--){
        scanf("%d %d",&n,&m);
        memset(g,0,sizeof(g));
        for(int i=0;i<m;i++){
            scanf("%d %d",&x[i],&y[i]);
            scanf("%d",&cost);
            g[x[i]][y[i]]+=cost;
            //maze[b][a]=cost;
        }
        int sum=0;
        start=1;End=n;
        sum=Max_Flow();
        printf("Case %d: %d\n",cas++,sum);

    }

    return 0;
}

模板四 FF算法：（辣鸡算法）

#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 205;
struct node {
	int v, w, next;
} edge[maxn*maxn];
int no, n, m;
int head[maxn], pre[maxn], rec[maxn], flow[maxn];
stack<int> stk;
void init() {
	no = 0;
	memset(head, -1, sizeof head);
}
//静态邻接表存边
void add(int u, int v, int w) {
	edge[no].v = v;
	edge[no].w = w;
	edge[no].next = head[u];
	head[u] = no++;
	edge[no].v = u;
	edge[no].w = 0;
	edge[no].next = head[v];
	head[v] = no++;
}
int dfs(int S, int T) {
	memset(pre, -1, sizeof pre);
	while(!stk.empty()) stk.pop();
	pre[S] = S;
	flow[S] = inf;
	stk.push(S);
	while(!stk.empty()) {	//用栈迭代替代dfs深搜
		int top = stk.top();
		stk.pop();
		int k = head[top];
		while(k != -1) {
			if(pre[edge[k].v] == -1 && edge[k].w > 0) {
				flow[edge[k].v] = min(flow[top], edge[k].w);
				pre[edge[k].v] = top;
				rec[edge[k].v] = k;
				stk.push(edge[k].v);
			}
			k = edge[k].next;
		}
		if(pre[T] != -1) return flow[T];
	}
	return -1;
}
int FF(int s, int t) {
	int ans = 0, add;
	while((add = dfs(s, t)) != -1) {	//直到找不到增广路
		ans += add;
		int k = t;
		while(k != s) {
			edge[rec[k]].w -= add;
			edge[rec[k]^1].w += add;
			k = pre[k];
		}
	}
	return ans;
}
int main() {
	ios::sync_with_stdio(0);
	int u, v, w;
	while(cin >> m >> n) {
		init();
		for(int i = 0; i < m; ++i) {
			cin >> u >> v >> w;
			add(u, v, w);
		}
		cout << FF(1, n) << endl;
	}
	return 0;
}

模板五 EK算法：（辣鸡算法）

#include <bits/stdc++.h>
using namespace std;
const int inf = 0x7fffffff;
const int maxn = 205;
struct node {
	int v, w, next;
} edge[maxn*maxn];
int no, n, m;
int head[maxn], pre[maxn], rec[maxn], flow[maxn];
queue<int> q;
void init() {
	no = 0;
	memset(head, -1, sizeof head);
}
//静态邻接表存边
void add(int u, int v, int w) {
	edge[no].v = v;
	edge[no].w = w;
	edge[no].next = head[u];
	head[u] = no++;
	edge[no].v = u;
	edge[no].w = 0;
	edge[no].next = head[v];
	head[v] = no++;
}
int dfs(int S, int T) {
	memset(pre, -1, sizeof pre);
	while(!q.empty()) q.pop();
	pre[S] = S;
	flow[S] = inf;
	q.push(S);
	while(!q.empty()) {
		int top = q.front();
		q.pop();
		int k = head[top];
		while(k != -1) {
			if(pre[edge[k].v] == -1 && edge[k].w > 0) {
				flow[edge[k].v] = min(flow[top], edge[k].w);
				pre[edge[k].v] = top;
				rec[edge[k].v] = k;
				q.push(edge[k].v);
			}
			k = edge[k].next;
		}
		if(pre[T] != -1) return flow[T];
	}
	return -1;
}
int EK(int s, int t) {
	int ans = 0, add;
	while((add = dfs(s, t)) != -1) {	//直到找不到增广路
		ans += add;
		int k = t;
		while(k != s) {
			edge[rec[k]].w -= add;
			edge[rec[k]^1].w += add;
			k = pre[k];
		}
	}
	return ans;
}
int main() {
	ios::sync_with_stdio(0);
	int u, v, w;
	while(cin >> m >> n) {
		init();
		for(int i = 0; i < m; ++i) {
			cin >> u >> v >> w;
			add(u, v, w);
		}
		cout << EK(1, n) << endl;
	}
	return 0;
}

模板六 Dinic：

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10000 + 5;
const int MAXM = 100000 + 5;
const int INF = 1e9;
int n,m;
int s,t;//源点 汇点
int maxflow;//答案
struct Edge {
    int next;
    int to,flow;
} l[MAXM << 1];
int head[MAXN],cnt = 1;
int deep[MAXN],cur[MAXN];//deep记录bfs分层图每个点到源点的距离
queue <int> q;
inline void add(int x,int y,int z) {
    cnt++;
    l[cnt].next = head[x];
    l[cnt].to = y;
    l[cnt].flow = z;
    head[x] = cnt;
    return;
}

int min(int x,int y) {
    return x < y ? x : y;
}

int dfs(int now,int t,int lim) {//分别是当前点，汇点，当前边上最小的流量
    if(!lim || now == t) return lim;//终止条件
//  cout<<"DEBUG: DFS HAS BEEN RUN!"<<endl;
    int flow = 0;
    int f;
    for(int i = cur[now]; i; i = l[i].next) {//注意！当前弧优化
        cur[now] = i;//记录一下榨取到哪里了
        if(deep[l[i].to] == deep[now] + 1 //谁叫你是分层图
            && (f = dfs(l[i].to,t,min(lim,l[i].flow)))) {//如果还能找到增广路
        flow += f;
            lim -= f;
            l[i].flow -= f;
            l[i ^ 1].flow += f;//记得处理反向边
            if(!lim) break;//没有残量就意味着不存在增广路
        }
    }
    return flow;
}

bool bfs(int s,int t) {
    for(int i = 1; i <= n; i++) {
        cur[i] = head[i];//拷贝一份head，毕竟我们还要用head
        deep[i] = 0x7f7f7f7f;
    }
    while(!q.empty()) q.pop();//清空队列 其实没有必要了
    deep[s] = 0;
    q.push(s);
    while(!q.empty()) {
        int tmp = q.front();
        q.pop();
        for(int i = head[tmp]; i; i = l[i].next) {
            if(deep[l[i].to] > INF && l[i].flow) {//有流量就增广
            //deep我赋的初值是0x7f7f7f7f 大于 INF = 1e9）
                deep[l[i].to] = deep[tmp] + 1;
                q.push(l[i].to);
            }
        }
    }
    if(deep[t] < INF) return true;
    else return false;
}

void dinic(int s,int t) {
    while(bfs(s,t)) {
        maxflow += dfs(s,t,INF);
    }
}

int main() {
    cin>>n>>m;//点数边数
    cin>>s>>t;
    int x,y,z;
    for(int i = 1; i <= m; i++) {
        scanf("%d %d %d",&x,&y,&z);
        add(x,y,z);
        add(y,x,0);
    }
    dinic(s,t);
    printf("%d",maxflow);
    return 0;
}

 

The stroke
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最大流_最大流模板_
09-30
供信息学奥林匹克竞赛选手使用 最大流的模板
最大流模板(Maximum Flow)
τ's blog
06-02 977
最大流模板(Maximum Flow) 一篇写得通俗易懂介绍最大流的文章:最大流模板【EdmondsKarp算法，简称EK算法，O(m^2n)】 残留网络 残存容量 c~f~(u, v) = c(u, v) - f(u, v); 算法导论中对残存网络的一些解释 一条边所能允许的反向流量最多将其正向流量抵消. 残存网络中的这些反向边允许算法将发送出来的流量发送回去. 而将流量从...
【模板】网络最大流
weixin_34250709的博客
03-04 168
https://www.luogu.org/problem/show?pid=3376 题目描述 如题，给出一个网络图，以及其源点和汇点，求出其网络最大流。 输入输出格式 输入格式： 第一行包含四个正整数N、M、S、T，分别表示点的个数、有向边的个数、源点序号、汇点序号。 接下来M行每行包含三个正整数ui、vi、wi，表示第i条有向边从ui出发，到达vi，边权为wi（即该边最大流...
【模板】最大流详细证明(Dinic+当前弧优化)(附:题- How Many to Be Happy?)
weixin_45819197的博客
04-06 1351
初识网络流-最大流==最小割 什么是网络流 网络流(network-flows)是一种类比水流的解决问题方法，与线性规划密切相关。网络流的理论和应用在不断发展。而我们今天要讲的就是网络流里的一种常见问题——最大流问题。 如下图： 最大流 (Dinic) 进而引出了最大流问题：从源点出发到达汇点，所能流入最大的流量。 增广路 那么我们如何知道S(源点)---->T(汇点)的最大流量呢？ 我们的思路是： 1.先找出一条增广路径，得到这条路径权值的最小值mins，之后该路径边上的流（权值）的值减去min
最大流模板(Edmond-Karp)
he_qingjun的博客
07-28 92
题目：https://www.luogu.com.cn/problem/P3376 学习心得： FF算法，EK算法敲了五遍才真正理解，理解了才发现原来挺简单的。。估计刚开始被网络流这个名头吓住了，，下意识以为很难，，两个星期学完了30多个算法，有一半敲了十遍以上，另一遍估计就敲了五遍左右，，心急以为早点学完打比赛就不会慌了，，然而等到我回头用心看的时候才是真的理解了，，虽然学了好多个算法，但是都是短时间学的，不能灵活的运用，不能根据题目建模，如果用到这些模板算法的时候，建模是最难的一部分，，不会分离出模型，
最大流模板（dinic）
IDrandom的专栏
08-09 280
//dinic #include&amp;lt;bits/stdc++.h&amp;gt; using namespace std; typedef long long LL; const int INF = 0x3f3f3f3f; const int maxm =120020; const int maxn =1210; struct Edge{ int u,v,w; int nxt; }e[m...
最小费用最大流模板
11-26
在提供的代码中，实现了一个最小费用最大流的模板，主要包含以下几个部分： 1. **数据结构**：定义了用于表示图的各种数据结构，如`first`、`next`、`u`、`v`、`w`、`c`、`lc`、`com`等。其中，`u`和`v`存储边的两...
isap最大流模板
03-30
isap模板
最大流模板.cpp dinic
02-08
最大流模板.cpp dinic
最大流EK模板
04-16
用stl队列的最大流模板，算法是Edmand-Karp，可直接使用，用于acm比赛的最大流问题解决，多数可以用Edmand-Karp解决
预流推进算法的最大流模板
08-13
预流推进算法是不同与增广路思想的另一种求最大流的算法，主要思想是把流从源点经过边，并通过调整顶点的标号来把流压入汇点。 该算法需要维护一个装有活跃顶点的标号，所谓活跃定点则是流出量小于流入量的顶点，则具有超额量，欲使该顶点平衡（流出==流入），则需要把该定点积累的流压出，被压入流的顶点只能是距离标号比该点标号小1且这条边未满流的顶点，若不存在这样的顶点但是改点仍未活跃顶点，则需要把该点的距离标号加1. 这只是利用普通的FIFO队列，为了加速算法，可以维护一个优先队列，以顶点的距离标号为优先级，距离标号大的先出列。
最大流（模板）
weixin_34307464的博客
04-20 96
最大流就是建一个反向边，所以说正向边加反向边之和就等于你一开始输入的值 1.EK（Edmond—Karp）算法 也就是广搜版 #include<cstdio> #include<iostream> #include<cstring> using namespace std; const int M=1999999,INF=999999...
网络流之最大流 模板
qq_52028570的博客
07-18 797
FF算法:有了Dinic，谁还用FF… EK算法:有了Dinic，谁还用EK… Dinic: #include<bits/stdc++.h> using namespace std; int tot,st,ed,i,j,n,m,head[1111111],ans,dep[1111111],q[1111111]; struct eat{ int wi,to,ne; }e[1111111]; void add(int x,int y,int z) { e[tot].wi=z; e[tot].t
洛谷 P3376 【【模板】网络最大流】
weixin_30768175的博客
02-04 106
题目描述 如题，给出一个网络图，以及其源点和汇点，求出其网络最大流。 输入 第一行包含四个正整数N、M、S、T，分别表示点的个数、有向边的个数、源点序号、汇点序号。 接下来M行每行包含三个正整数ui、vi、wi，表示第i条有向边从ui出发，到达vi，边权为wi（即该边最大流量为wi） 输出 一行，包含一个正整数，即为该网络的最大流。 样例输入 4 5 4 3 4 2 30 ...
hdu 3549 Flow Problem（最大流模板题）
08-10 2596
hdu 3549 Flow Problem（最大流模板题）
【模板】最大流模板（dinic）
Tricksterism
04-12 95
【模板】最大流模板（dinic） 题目描述 如题，给出一个网络图，以及其源点和汇点，求出其网络最大流。 输入输出格式 输入格式： 第一行包含四个正整数N、M、S、T，分别表示点的个数、有向边的个数、源点序号、汇点序号。 接下来M行每行包含三个正整数ui、vi、wi，表示第i条有向边从ui出发，到达vi，边...
洛谷P3376【模板】网络最大流
forezxl的博客
06-13 731
最大流
(模板题)loj #127. 最大流 加强版(hlpp)
长路漫漫 唯剑作伴
08-24 1338
题目链接：https://loj.ac/problem/127 最大流hlpp模板(原作者是xehoth，我就改了改拿来用用) 请根据题目要求做修改。 Note:可将vector改为链式前向星，代码我就不贴出来了，如有需要请私信我。 update(2018.9.29)： 算是对这个板子的总结。 在检验板子的时候发现这个东西跑网络流时间下限较高，但上限小，适合跑边数多的图，毕竟O()，时...
2021年制动系统行业财务部门表格模板汇总 .pdf
09-28
2021年各行业财务部门表格模板

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值