费用流

最新推荐文章于 2020-09-24 13:13:36 发布
最新推荐文章于 2020-09-24 13:13:36 发布
阅读量314 收藏
点赞数
文章标签： SPFA costflow 费用流 带权二分图
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35755187/article/details/80143102
版权


费用流模板 LOJ

LOJ上模板68ms还挺快 

点击打开链接

要跑一遍最大费用最大流和最小费用最大流 每次跑之前重新建图 范围很小没什么问题

每次SPFA找出最短/最长路 然后blabla 把费用W当成边权

#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int maxn = 5007;
#define Min(_A,_B) (_A>_B?_B:_A)
const int inf = 0x3f3f3f3f;
struct edge {
	int v, c, w, nxt;
}e[maxn << 1];

int head[maxn], eid = 0, d[maxn], pre[maxn], s, t, a[101], b[101], n, m, h[101][101];
bool inq[maxn];
//带权二分图匹配
void insert(int u, int v, int c, int w) {
	e[eid].v = v;  e[eid].w = w; e[eid].c = c;e[eid].nxt = head[u];  head[u] = eid++;
	e[eid].v = u;  e[eid].nxt = head[v];  e[eid].w = -w; e[eid].c = 0;  head[v] = eid++;
}

bool spfa() {
	memset(inq, 0, sizeof(inq));
	memset(d, -inf, sizeof(d));
	memset(pre, -1, sizeof(pre));
	queue<int> q;
	q.push(s);
	inq[s] = true;
	d[s] = 0;
	int u, v, i;
	while (!q.empty()) {
		u = q.front(); q.pop();
		inq[u] = false;
		for (i = head[u]; ~i; i = e[i].nxt) {
			if (e[i].c) {
				v = e[i].v;
				if (d[u] + e[i].w>d[v]) {//最长路解决最大费用最大流问题
					d[v] = d[u] + e[i].w;
					pre[v] = i;
					if (!inq[v]) {
						inq[v] = true;
						q.push(v);
					}
				}
			}
		}
	}
	return pre[t] != -1;
}
bool spfa_min() {
	memset(inq, 0, sizeof(inq));
	memset(d, inf, sizeof(d));
	memset(pre, -1, sizeof(pre));
	queue<int> q;
	q.push(s);
	inq[s] = true;
	d[s] = 0;
	int u, v, i;
	while (!q.empty()) {
		u = q.front(); q.pop();
		inq[u] = false;
		for (i = head[u]; ~i; i = e[i].nxt) {
			if (e[i].c) {
				v = e[i].v;
				if (d[u] + e[i].w<d[v]) {//最短路解决最小费用最大流问题
					d[v] = d[u] + e[i].w;
					pre[v] = i;
					if (!inq[v]) {
						inq[v] = true;
						q.push(v);
					}
				}
			}
		}
	}
	return pre[t] != -1;
}

int costflow() {
	int res = 0;
	while (spfa()) {
		int i, flow = inf;
		for (i = t; i != s; i = e[pre[i] ^ 1].v) {
			flow = Min(flow, e[pre[i]].c);//寻找路径上的最小流量
		}
		for (i = t; i != s; i = e[pre[i] ^ 1].v) {
			e[pre[i] ^ 1].c += flow;
			e[pre[i]].c -= flow;
			res += e[pre[i]].w*flow;
		}
	}
	return res;
}
int costflow_min() {
	int res = 0;
	while (spfa_min()) {
		int i, flow = inf;
		for (i = t; i != s; i = e[pre[i] ^ 1].v) {
			flow = Min(flow, e[pre[i]].c);
		}
		for (i = t; i != s; i = e[pre[i] ^ 1].v) {
			e[pre[i] ^ 1].c += flow;
			e[pre[i]].c -= flow;
			res += e[pre[i]].w*flow;
		}
	}
	return res;
}
inline int read() {
	int s = 0, f = 1; char c = getchar(); while (c<'0' || c>'9') { if (c == '-') f = -1; c = getchar(); }
	while (c >= '0'&&c <= '9') { s = s * 10 + c - '0'; c = getchar(); }
	return s*f;
}

int main() {
	m = read(); n = read(); int i, j;
	memset(head, -1, sizeof(head));
	s = 0; t = n+m+1;
	for (i = 1; i <= m; i++) {
		a[i] = read();
		insert(s, i, a[i], 0);
	}
	for (i = 1; i <= n; i++) {
		b[i] = read();
		insert(i + m, t, b[i], 0);
	}

	for (i = 1; i <= m; i++)
		for (j = 1; j <= n; j++) {
			h[i][j] = read();
			insert(i, j + m, inf, h[i][j]);
	}
	printf("%d\n", costflow_min());
	eid = 0;
	memset(head, -1, sizeof(head));
	for (i = 1; i <= m; i++) insert(s, i, a[i], 0);
	for (i = 1; i <= n; i++) insert(i + m, t, b[i], 0);
	for (i = 1; i <= m; i++)
		for (j = 1; j <= n; j++)
			insert(i, j + m, inf, h[i][j]);
	printf("%d", costflow());
	//getchar();
	return 0;
}
SCOI2007 修车

拆点 把每个师傅拆成n个点表示倒数第i个修的是xxx

比如师傅i按顺序修了三辆车，时间分别是T1，T2,T3,那么总时间是T1+（T1+T2） +（T1+T2+T3）

那么可以设倒数第i个修的车对应的弧费用为T*i

BZOJ上TLE了 时限1s过不去 但是洛谷AC了

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#define Max(_A,_B) (_A>_B?_A:_B)
#define Min(_A,_B) (_A>_B?_B:_A)
const int inf = 0x3f3f3f3f;
using namespace std;
const int maxn = 370007;//10*60*60
int n, m;
struct edge {
	int v, w, c, nxt;
}e[maxn<<1];
int p[maxn], eid = 0, dis[maxn],pre[maxn],s,t;
bool inq[maxn];
void insert(int u, int v, int c, int w) {
	e[eid].v = v; 
	e[eid].w = w;
	e[eid].c = c;
	e[eid].nxt = p[u];
	p[u] = eid++;
}
void addedge(int u, int v, int c, int w) {
	insert(u, v, c, w);
	insert(v, u, 0, -w);
}
bool spfa() {
	queue<int> q;
	q.push(s);
	memset(dis, inf, sizeof(dis));
	memset(pre, -1, sizeof(pre));
	memset(inq, false, sizeof(inq));
	dis[s] = 0;
	inq[s] = true;
	while (!q.empty()) {
		int u = q.front(); 
		q.pop();
		inq[u] = false;
		for (int i = p[u]; i!=-1; i = e[i].nxt){
			if (e[i].c) {
				int v = e[i].v;
				if (dis[u] + e[i].w < dis[v]) {
					dis[v] = dis[u] + e[i].w;
					pre[v] = i;
					if (!inq[v]) {
						inq[v] = true;
						q.push(v);
					}
				}
			}
		}
	}
	return pre[t] != -1;
}
double cost_flow() {
	double res = 0;
	while (spfa()) {
		int flow = inf;
		for (int i = t; i != s; i = e[pre[i] ^ 1].v) {
			flow = Min(flow, e[pre[i]].c);
			//printf("1");
		}
		for (int i = t; i != s; i = e[pre[i] ^ 1].v) {
			e[pre[i]].c -= flow;
			e[pre[i] ^ 1].c += flow;
			res += e[pre[i]].w*flow;
		}
	}

	return res;
}
inline int read() {
	int s = 0, f = 1; char c = getchar(); while (c<'0' || c>'9') { if (c == '-') f = -1; c = getchar(); }
	while (c >= '0'&&c <= '9') { s = s * 10 + c - '0'; c = getchar(); }
	return s*f;
}
int g[61][11];
int main() {
	m = read();
	n = read();
	s = 0; t = m*n+n+1;
	memset(p, -1, sizeof(p));
	for(int i=1;i<=n;i++)
		for (int j = 1; j <= m; j++) {
			g[i][j] = read();
		}
	for (int i = 1; i <= n*m; i++) addedge(s, i, 1, 0);
	for (int i = n*m + 1; i <= n*m + n; i++)
		addedge(i, t, 1, 0);
	for (int i = 1; i <= m; i++)
		for (int j = 1; j <= n; j++)//次序
			for (int k = 1; k <= n; k++)//客人编号
				addedge((i - 1)*n + j, m*n + k, 1, g[k][i] * j);
	printf("%.2lf\n", cost_flow()/n );
	//getchar();
	return 0;
}

NOI2012 美食节

建图方法和SCOI2007修车一样 但是数据更强了需要动态连边
然后注意到可以不把每道菜拆成P[i]个点 而是把S点连向表示该到菜的边的容量设成P[i] 就可以沿这条弧增广P[i]次了
在费用流过程中计算边对应的厨师和菜的次序时取模炸了 被m=1的数据卡掉了  发现原来的取模方式无法算出厨师做的第$\sum P$道菜 要特判 调了好久/_ \
动态连边的原理是，如果最小费用最大流增广路经过了厨师i做的倒数第j道菜的点 之前就一定经过了倒数第j-1道菜

因为倒数第1道菜的对应弧容量最小 （按修车那题的建模方式）

时限有点紧 还可以在spfa的同时预处理出对应增广路的流量 记为incf

#include<algorithm>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
#define Min(_A,_B) (_A<_B?_A:_B)
const int maxn = 81007,inf=0x3f3f3f3f;
struct edge {
	int v, w, c, nxt;
}e[500007];
int head[maxn], eid = 0, d[maxn],s,
t,n,m,p[maxn],u,v,pre[maxn],incf[maxn],sp;
bool inq[maxn];
int g[41][101];
void insert(int u, int v, int c, int w) {
	e[eid].v = v; 
	e[eid].c = c; 
	e[eid].w = w; 
	e[eid].nxt = head[u];
	head[u]=eid++;
}
void addedge(int u, int v, int c, int w) {
	insert(u, v, c, w);
	insert(v, u, 0, -w);
}
void init() {
	memset(head, -1, sizeof(head));
	eid = 0;
}
/*动态加边的思路是 如果增广路流经x->t 与x相连的菜
表示厨师j做的倒数第x-n-(j-1)*p道菜
根据此题的构图
	厨师i做的第j道菜耗时g[j][i]
	第j+1道菜耗时g[j+1][i]+g[j][i]
	第j+2道菜耗时g[j+2][i]+g[j+1][i]+g[j][i]
	总时长为g[j][i]*3+g[j+1][i]*2+g[j+2][i]
	故我们设各个菜与S相连 容量为pi
	厨师与t相连 每个厨师j占的点编号范围为
	n+p*(j-1)+1到n+p*j
	即把每个厨师拆成至多p个点。
有T[x]<T[x+1] 如果没有连向x 就不加连向x+1的边
*/
bool spfa() {
	memset(d, inf, sizeof(d));
	memset(inq, false, sizeof(inq));
	memset(pre, -1, sizeof(pre));
	queue<int> q;q.push(s);
	d[s] = 0;inq[s] = true;incf[s] = inf;
	while (!q.empty()) {
		u = q.front(); q.pop();inq[u] = false;
		for (int i = head[u]; ~i; i = e[i].nxt) {
				if (e[i].c>0&&d[e[i].v] > d[u] + e[i].w) {
					v=e[i].v;
					d[v] = d[u] + e[i].w;pre[v] = i;
					incf[v] = Min(incf[u], e[i].c);
					if (!inq[v]) {	inq[v] = true;q.push(v);}
				}
		}
	}
	return pre[t]!=-1;
}
int ans = 0,x;
void cost_flow() {
	while(spfa()){
		for(int i=t;i!=s;i=e[pre[i]^1].v){
			e[pre[i]].c-=incf[t];
			e[pre[i]^1].c+=incf[t];
		}
		ans+=d[t]*incf[t];
		x=e[pre[t]^1].v;//增广路连向t的边（厨师拆出的点）
		//获取厨师编号j：由x=n+(j-1)*p+k知，
		//j=(x-n-1)/p+1
		//厨师现在是倒数第k道菜
		//k=(x-n-1)%p+1
		int a=(x-n)/sp+1,b=(x-n+1)%sp;
		if(!b) b=sp;
		//printf("%d %d %d\n",x,a,b);
		addedge(x+1,t,1,0);
		for(int i=1;i<=n;i++){
			addedge(i,x+1,1,g[i][a]*b);
		}

	}
}
inline int read(){
	int s=0,f=1;char c=getchar();while(c<'0'||c>'9') {if(c=='-') f=-1;c=getchar();}
	while(c>='0'&&c<='9') {s=s*10+c-'0';c=getchar();}
	return s*f;
}
int main(){
	n=read();m=read();
	s=0;
	init();
	for(int i=1;i<=n;i++){
		p[i]=read();sp+=p[i];
		addedge(s,i,p[i],0);//p[i]道菜匹配p[i]次
	}
	t=sp*m+n+1;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++){	
			g[i][j]=read();
			//连接每个厨师做的倒数第一道菜
		}
	for(int j=1;j<=m;j++){
		x=n+(j-1)*sp+1;//厨师j做的倒数第1道菜与x连
		for(int i=1;i<=n;i++){
			addedge(i,x,1,g[i][j]);
		}
		addedge(x,t,1,0);
	}
	//printf("%d\n",sp);
	cost_flow();
	printf("%d",ans);
	return 0;
}

Yjmstr
关注
[学习笔记]费用流
weixin_34014277的博客
11-27 209
一些内容在另一篇博客 [学习笔记]网络流 有的时候要保证最大的情况下，费用尽可能优。 就要用费用流了。 目前所涉及的费用流，都是在最大流的前提下 所以，当题目可以转化成，在保证。。。的情况下，最优化。。。 也许就可以尝试费用流了。 （同样意味着选择， 最小割没有什么最大流的前提，可以没有什么限制地，割掉一些边即可。 但是，每条边必须割掉，不能“割一部分”，...
【模板】费用流：概念及证明过程
最新发布
m0_60738889的博客
06-27 854
给定一个包含n个点m条边的图，并给定每条边的容量和费用，边的容量非负。图中可能存在重边和自环，保证费用不会存在负环。求从S到T的最大流，以及在流量最大时的最小费用。
费用流详解
Ripped的博客
04-25 6236
费用流，也叫作最小费用最大流，是指在普通的网络流图中，每条边的流量都有一个单价，求出一组可行解，使得在满足它是最大流的情况下，总的费用最小。 （最大费用最大流同理，费用改成负的就行） 做法一般都是简单地SPFA（也就是和EK算法类似），时间复杂度比较高，所以一般规模都挺小的。 1、找到一条从源点到汇点的路径，使得这条路径的单价和最小。换句话说以流量的单价作为边权值跑最短路，注意因为不会有负环（
基于最小费用流(MCF)法的相位解包裹理论与实验验证-含Matlab代码.zip
05-14
最小费用流（Minimum Cost Flow, MCF）法是一种网络优化技术，常被用于解决此类问题，因为它能够有效地处理这些相位跳跃，并确保解包裹过程的全局最优性。 最小费用流算法源自运筹学，其核心思想是在网络中寻找一个...
最小费用流的原始对偶 (Primal-Dual) 算法.docx
05-06
"最小费用流的原始对偶 (Primal-Dual) 算法" 该算法是融合了直接 SPFA 算法和 KM 重标号算法的优点，实现了最小费用流的计算。该算法的主要过程是反复交替进行最短路和最大流的计算，利用 Reduced Cost 缩小了费用...
基于Busacker-Gowan迭代算法最小费用流代码.zip
03-22
在数学建模领域，Busacker-Gowan迭代算法是一种用于求解最小费用流问题的有效方法。最小费用流问题是在网络流理论中的一个重要分支，它旨在找到一个流，使得在网络中从源点到汇点的总流量最大，同时使总的费用（如...
MCMF.zip_MCMF_MCMF C++_最小费用流
07-14
在标题"MCMF.zip_MCMF_MCMF C++_最小费用流"中，我们可以理解这是一个关于MCMF算法的C++实现，可能包含源代码和相关文档。"MCMF"是Minimum Cost Maximum Flow的缩写，而"MCMF C++"则表明了这个实现使用的编程语言。 ...
无容量限制的最小费用流问题 (2004年)
05-10
最小费用流问题（Minimum Cost Flow Problem，简称MCFP）是网络流理论中的一个重要问题，广泛应用于通信、运输、物流等领域。该问题主要目标是在满足网络中流量守恒和边的容量限制的条件下，寻找一个费用最低的流...
[SDOI2013] 费用流
HT008的Blog
03-29 271
题目描述： 给出一个流量网络，给出参数费用 T 题目分析： Bob/肯定会吧全部的T放在最大流量边上，所以我们必须让最大流量边最小 先跑最大流，然后二分最大流量边，看新的网络是否最大流等于原来网络的最大流 题目链接： BZOJ 3130 Luogu 3305 Ac 代码： #include &lt;cstdio&gt; #include &lt;iostream&...
room——费用流
20164225的博客
08-02 242
链接：https://www.nowcoder.com/acm/contest/143/E 来源：牛客网   题目描述 Nowcoder University has 4n students and n dormitories ( Four students per dormitory). Students numbered from 1 to 4n. And in the first ye...
模板 - 费用流
繁凡さん的博客
08-22 653
整理的算法模板合集： ACM模板 文章目录一、最小费用最大流类dinic模板二、最大费用最大流解决二分图带权最大匹配三、费用提前计算+动态开点 一、最小费用最大流 类dinic模板 时间复杂度为O(nmf)O(nmf)O(nmf)， fff 为最大流量， 效率较高，一般不会被卡 #include<iostream> #include<cstdio> #include<algorithm> #include<cstring> #include<queu
学习笔记：费用流
weixin_44043668的博客
09-24 3578
上讲习题 AcWing 2279 这个题看着很懵，这根本不是最小割啊！然而我们可以思考一下，这种ab\cfrac{a}{b}ba​的模型，且求的最小或最大值，那么不就是分数规划吗？于是，我们可以设平均值位ggg，则：h(g)=∑e∈Cwe−∣C∣×gh(g)=\displaystyle\sum_{e\in C}w_e-|C|\times gh(g)=e∈C∑​we​−∣C∣×g=∑e∈Cwe−∑e∈Cg=\displaystyle\sum_{e\in C}w_e-\displaystyle\sum_{e\i
费用流（板子）
Harington的博客
10-01 393
最小费用最大流 最大费用最小流，建边的时候，把花费和流量调换位置 最大费用最大流，建边的时候，把正向的费用存为负值，结果取负号 Spfa:链式向前星 const int maxn = ; const int inf = 0x3f3f3f3f; //path用来保存找到一条费用最小的增广路 int path[maxn], dis[maxn], head[maxn], vis[maxn], ...
最小费用流算法详解与应用
"第九讲_最小费用流 - 算法思想-图论与算法" 在图论和算法领域，最小费用流问题是一个重要的优化问题，它涉及到在网络中找到一条能够最大化流量同时最小化总费用的路径。最小费用流问题通常出现在资源分配、物流...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值