POJ 3436 ACM Computer Factory 网络流 最大流

于 2019-07-29 22:39:13 发布
阅读量110 收藏
点赞数
分类专栏： 网络流 文章标签： ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42397248/article/details/97691450
版权

题意：给n台机器，每个机器有输入输出规范，还有生产电脑的最大产能，输入规范中描述了每个部件是否是必需的，0表示不需要，1表示必需，2表示都行，输出规范中描述了机器输出的每个零件，0表示不输出该零件，1表示输出该零件。求最大总产能，以及需要连接的机器，及连接机器的产能。
思路：用最大流来求，难的主要是图的建模：每个机器当作一个点，由于每个点有最大容量，故可将其拆成两个点，把最大容量放到边上，若机器输入都是0，则将其连到源点，若输出都是1，将其连到汇点，若两个机器的输入输出相匹配，则在其之间连一条边，之后根据这样建的图来求最大流。需要注意的是连接源点时若输入为2也表示可以连接，WA多次主要是这个原因。
Ford-Fulkerson算法：每次通过dfs来求增广路，并沿其增广

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<vector>
using namespace std;
typedef long long ll;
const int maxn = 1005;
const int inf = 0x3f3f3f3f;
int p, n, vis[maxn];
struct edge {
	int to, cap, rev;
	edge(int to = 0, int cap = 0, int rev = 0) : to(to), cap(cap), rev(rev) {}
};
struct node {
	int c, in[15], out[15];
}com[maxn];
vector<edge> g[maxn];
vector<edge> res;
void addedge(int from, int to, int cap) 
{
	g[from].push_back(edge(to, cap, g[to].size()));
	g[to].push_back(edge(from, 0, g[from].size()-1));
}
int dfs(int v, int t, int f)
{
	if (v == t) return f;
	vis[v] = 1;
	for (int i = 0; i < g[v].size(); i++) {
		edge &e = g[v][i];
		if (!vis[e.to] && e.cap > 0) {
			int d = dfs(e.to, t, min(f, e.cap));
			if (d > 0) {
				e.cap -= d;
				g[e.to][e.rev].cap += d;
				return d;
			}
		}
	}
	return 0;
}
int solve(int s, int t)
{
	int flow = 0;
	for (;;) {
		memset(vis, 0, sizeof(vis));
		int f = dfs(s, t, inf);
		if (f == 0) return flow;
		flow += f;
	}
}
int main()
{
	while (cin >> p >> n) {
		res.clear();
		for (int i = 0; i <= 2*n+1; i++) {
			g[i].clear();
		}
		for (int i = 1; i <= n; i++) {
			cin >> com[i].c;
			for (int j = 1; j <= p; j++)
				cin >> com[i].in[j];
			for (int j = 1; j <= p; j++)
				cin >> com[i].out[j];
		}
		int N = 2*n+1;
		for (int i = 1; i <= n; i++)
			addedge(2*i-1, 2*i, com[i].c);
		for (int i = 1; i <= n; i++) {
			int ok = 0;
			for (int j = 1; j <= p; j++) {
				if (com[i].in[j] != 0 && com[i].in[j] != 2) {
					ok = 1;
					break;
				}
			}
			if (!ok)
				addedge(0, 2*i-1, inf);
			ok = 0;
			for (int j = 1; j <= p; j++) {
				if (com[i].out[j] != 1) {
					ok = 1;
					break;
				}
			}
			if (!ok)
				addedge(2*i, N, inf);
			for (int j = 1; j <= n; j++) {
				ok = 0;
				for (int k = 1; k <= p; k++) {
					if (j != i && !(com[i].out[k] == com[j].in[k] || com[j].in[k] == 2)){
						ok = 1;
						break;
					} 
				}
				if (!ok) {
					addedge(2*i, 2*j-1, inf);
				}
			}
		}
		vector<edge> temp[maxn];
		for (int i = 0; i <= N; i++) {
			temp[i] = vector<edge>(g[i]);
		}
		printf("%d ", solve(0, N));
		for (int i = 1; i <= n; i++) {
			for (int j = 0; j < g[2*i].size(); j++) {
				if (g[2*i][j].cap < temp[2*i][j].cap && g[2*i][j].to != N) 
					res.push_back(edge(i, temp[2*i][j].cap-g[2*i][j].cap, g[2*i][j].to/2+1));
			}
		}
		printf("%d\n", res.size());
		for (int i = 0; i < res.size(); i++)
			printf("%d %d %d\n", res[i].to, res[i].rev, res[i].cap);
	}	
	return 0;
}

Edmonds-Karp算法：FF算法的特例，用bfs来求增广路，每次找的都是最短的增广路，最短增广路的长度在增广过程中不会变短。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
typedef long long ll;
const int maxn = 105;
const int inf = 0x3f3f3f3f;
int p, n, vis[maxn], g[maxn][maxn], path[maxn], flow[maxn], N, temp[maxn][maxn];
struct edge {
	int to, cap, rev;
	edge(int to = 0, int cap = 0, int rev = 0) : to(to), cap(cap), rev(rev) {}
};
struct node {
	int c, in[15], out[15];
}com[maxn];
vector<edge> res;
int bfs()
{
	queue<int> q;
	memset(path, -1, sizeof(path));
	path[0] = 0;
	flow[0] = inf;
	q.push(0);
	while (!q.empty()) {
		int t = q.front(); q.pop();
		if (t == N) break;
		for (int i = 0; i <= N; i++) {
			if (i != 0 && path[i] == -1 && g[t][i]) {
				flow[i] = flow[t] < g[t][i] ? flow[t] : g[t][i];
				q.push(i);
				path[i] = t;
			}
		}
	}
	if (path[N] == -1) return -1;
	return flow[N];
}
int solve()
{
	int maxflow = 0, step, now, pre;
	while ((step = bfs()) != -1) {
		maxflow += step;
		now = N;
		while (now != 0) {
			pre = path[now];
			g[pre][now] -= step;
			g[now][pre] += step;
			now = pre;
		}
	}
	return maxflow;
}
int main()
{
	while (cin >> p >> n) {
		res.clear();
		memset(g, 0, sizeof(g));
		for (int i = 1; i <= n; i++) {
			cin >> com[i].c;
			for (int j = 1; j <= p; j++)
				cin >> com[i].in[j];
			for (int j = 1; j <= p; j++)
				cin >> com[i].out[j];
		}
		N = 2*n+1;
		for (int i = 1; i <= n; i++)
			g[2*i-1][2*i] = com[i].c;
		for (int i = 1; i <= n; i++) {
			int ok = 0;
			for (int j = 1; j <= p; j++) {
				if (com[i].in[j] != 0 && com[i].in[j] != 2) {
					ok = 1;
					break;
				}
			}
			if (!ok)
				g[0][2*i-1] = inf;
			ok = 0;
			for (int j = 1; j <= p; j++) {
				if (com[i].out[j] != 1) {
					ok = 1;
					break;
				}
			}
			if (!ok)
				g[2*i][N] = inf;
			for (int j = 1; j <= n; j++) {
				if (i == j)
					continue;
				ok = 0;
				for (int k = 1; k <= p; k++) {
					if (!(com[i].out[k] == com[j].in[k] || com[j].in[k] == 2)){
						ok = 1;
						break;
					} 
				}
				if (!ok) {
					g[2*i][2*j-1] = inf;
				}
			}
		}
		memcpy(temp, g, sizeof(g));
		printf("%d ", solve());
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n; j++) {
				if (g[2*i][2*j-1] < temp[2*i][2*j-1]) 
					res.push_back(edge(i, temp[2*i][2*j-1]-g[2*i][2*j-1], j));
			}
		}
		printf("%d\n", res.size());
		for (int i = 0; i < res.size(); i++)
			printf("%d %d %d\n", res[i].to, res[i].rev, res[i].cap);
	}	
	return 0;
}

实际上这个实现比第一个实现要慢，因为第一个实现中根据每个点的边来遍历，而第二个实现中遍历所有点来查找两点之间的边
Dinic算法：EK算法的优化版本，复杂度在三个里面是最优的

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
typedef long long ll;
const int maxn = 105;
const int inf = 0x3f3f3f3f;
int p, n, vis[maxn], level[maxn], iter[maxn], N;
struct edge {
	int to, cap, rev;
	edge(int to = 0, int cap = 0, int rev = 0) : to(to), cap(cap), rev(rev) {}
};
struct node {
	int c, in[15], out[15];
}com[maxn];
vector<edge> g[maxn];
vector<edge> res;
void addedge(int from, int to, int cap) 
{
	g[from].push_back(edge(to, cap, g[to].size()));
	g[to].push_back(edge(from, 0, g[from].size()-1));
}
void bfs(int s)
{
	memset(level, -1, sizeof(level));
	queue<int> q;
	level[s] = 0;
	q.push(s);
	while (!q.empty()) {
		int t = q.front(); q.pop();
		for (int i = 0; i < g[t].size(); i++) {
			edge &e = g[t][i];
			if (e.cap > 0 && level[e.to] < 0) {
				level[e.to] = level[t] + 1;
				q.push(e.to);
			}
		}
	}
}
int dfs(int v, int t, int f)
{
	if (v == t) return f;
	vis[v] = 1;
	for (int &i = iter[v]; i < g[v].size(); i++) {
		edge &e = g[v][i];
		if (level[v] < level[e.to] && e.cap > 0) {
			int d = dfs(e.to, t, min(f, e.cap));
			if (d > 0) {
				e.cap -= d;
				g[e.to][e.rev].cap += d;
				return d;
			}
		}
	}
	return 0;
}
int solve(int s, int t)
{
	int flow = 0;
	for (;;) {
		bfs(s);
		if (level[t] < 0) return flow;
		memset(iter, 0, sizeof(iter));
		int f;
		while ((f = dfs(s, t, inf)) > 0)
			flow += f;
	}
}
int main()
{
	while (cin >> p >> n) {
		res.clear();
		memset(g, 0, sizeof(g));
		for (int i = 1; i <= n; i++) {
			cin >> com[i].c;
			for (int j = 1; j <= p; j++)
				cin >> com[i].in[j];
			for (int j = 1; j <= p; j++)
				cin >> com[i].out[j];
		}
		N = 2*n+1;
		for (int i = 1; i <= n; i++)
			addedge(2*i-1, 2*i, com[i].c);
		for (int i = 1; i <= n; i++) {
			int ok = 0;
			for (int j = 1; j <= p; j++) {
				if (com[i].in[j] != 0 && com[i].in[j] != 2) {
					ok = 1;
					break;
				}
			}
			if (!ok)
				addedge(0, 2*i-1, inf);
			ok = 0;
			for (int j = 1; j <= p; j++) {
				if (com[i].out[j] != 1) {
					ok = 1;
					break;
				}
			}
			if (!ok)
				addedge(2*i, N, inf);
			for (int j = 1; j <= n; j++) {
				if (i == j)
					continue;
				ok = 0;
				for (int k = 1; k <= p; k++) {
					if (!(com[i].out[k] == com[j].in[k] || com[j].in[k] == 2)){
						ok = 1;
						break;
					} 
				}
				if (!ok) {
					addedge(2*i, 2*j-1, inf);
				}
			}
		}
		vector<edge> temp[maxn];
		for (int i = 0; i <= N; i++) {
			temp[i] = vector<edge>(g[i]);
		}
		printf("%d ", solve(0, N));
		for (int i = 1; i <= n; i++) {
			for (int j = 0; j < g[2*i].size(); j++) {
				if (g[2*i][j].cap < temp[2*i][j].cap && g[2*i][j].to != N) 
					res.push_back(edge(i, temp[2*i][j].cap-g[2*i][j].cap, g[2*i][j].to/2+1));
			}
		}
		printf("%d\n", res.size());
		for (int i = 0; i < res.size(); i++)
			printf("%d %d %d\n", res[i].to, res[i].rev, res[i].cap);
	}	
	return 0;
}
Huglight
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POJ3436-ACM Computer Factory
07-30
北大POJ3436-ACM Computer Factory 解题报告+AC代码
POJ3436 ACM Computer Factory
weixin_30794491的博客
10-19 130
POJ3436 ACM Computer Factory Time Limit:1000MS Memory Limit:65536K Total Submissions:3345 Accepted:1112 Special Judge Description As you know, all the computer...
POJ 3436 ACM Computer Factory（网络流 拆点）
AIDreamer
08-24 661
POJ 3436题目大意 有一些机器用来装配电脑，每个电脑由P个部件构成，装配机要求传输过来的电脑有一定要求，一组P个数分别表示对每个部件的要求：0表示不需要这个部件，1表示需要这个部件，2表示有没有都可以。装配机的输出也有一定格式，也是P个数：0表示没有这个部件，1表示有这个部件。每个装配机有个效率可以理解成每小时装配多少个。装配机之间的连接不耗时，问这个网络，每小时最多装配多少个。 分析首先
POJ - 3436 ACM Computer Factory （拆点+网络流）
柳予欣的三味书屋~
08-08 272
ACM Computer Factory Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 9241   Accepted: 3412   Special Judge Description As you know, all the computers used for ACM ...
洛谷P1231教辅的组成（网络流 + 拆点）
Karshilov的博客
12-15 318
网络流可以用来解决各种匹配问题，我们是知道的，比如二分匹配，这题事实上也是一个匹配问题，但是要注意……拆点！！为什么呢？因为满足题意的匹配中，书是只能匹配一份答案和练习册的，不拆点限流的话，一本书就可能会匹配多组，拆点如下e.g. : 剩下的就是模板了 上代码：#include #define For(a,b,c,d) for(int a=b;a<=c;a+=d) #define m
poj 3436 ACM Computer Factory (最大流 拆点建图 找路径）@
MR CODER
03-13 257
As you know, all the computers used for ACM contests must be identical, so the participants compete on equal terms. That is why all these computers are historically produced at the same factory. Ever
poj-ACM.zip_ 1706 References_ACM_ACM习题
09-24
本文件是ACM里的一些题目的源码、原题和习题的分析及详细解答。欢迎各位下载
ACM.zip_ACM_poj_poj3187_poj3669
09-23
poj两道题的c++实现。已经测试过可以通过oj
POJ2195-Going Home【费用流】
08-30
北大POJ2195-Going Home【费用流】 解题报告+AC代码 http://blog.csdn.net/lyy289065406/article/details/6732762
网络流（最大流）SAP源码
10-08
最短增广路算法的实现 并加上了gap优化和当前弧优化 代码为POJ3469（dual core）的源码
python自学教程-04-自定义JavaScript.ev4.rar
05-21
python自学教程-04-自定义JavaScript.ev4.rar
严蔚敏数据结构全套C语言实现
05-21
严蔚敏数据结构全套C语言实现
Java_Android的可扩展媒体播放器.zip
05-21
Java_Android的可扩展媒体播放器
源代码-DBAdmin 在线Access数据库管理程序 v2.3.zip
最新发布
05-21
源代码-DBAdmin 在线Access数据库管理程序 v2.3.zip
Apache Dubbo的java实现RPC和微服务框架.zip
05-21
Apache Dubbo的java实现RPC和微服务框架
ubuntu20.04下编译mysql驱动项目源码
05-21
ubuntu20.04下编译mysql驱动项目源码,编译项目驱动后拷贝到对应位置 scp libqsqlmysql.so /home/pc/Qt5.14.2/Tools/QtCreator/lib/Qt/plugins/sqldrivers scp libqsqlmysql.so /home/pc/Qt5.14.2/5.14.2/gcc_64/plugins/sqldrivers sudo scp libqsqlmysql.so /usr/lib/x86_64-linux-gnu
数据分析是一个复杂而系统的过程
05-21
数据分析是一个复杂而系统的过程
激光雷达模拟数据采集哈哈哈
05-21
我么采用几个黄磊经重新生成萨沙时常
f103系列启动文件 各种都有
05-21
startup_stm32f10系列的startup_stm32f10x_cl.s startup_stm32f10x_hd.s startup_stm32f10x_hd_vl.s startup_stm32f10x_ld.s startup_stm32f10x_ld_vl.s startup_stm32f10x_md.s startup_stm32f10x_md_vl.s startup_stm32f10x_xl.s
POJ2135 Farm Tour —— 最小费用最大流
05-25
输出从 1 到 N 的最小费用最大流，如果无法到达，则输出 -1。 数据范围 1≤N≤1000 1≤M≤10000 1≤a,b≤N 1≤w≤10000 输入样例 4 5 1 2 1 2 3 2 3 4 3 1 3 4 2 4 3 输出样例 6 算法1 (最小费用最大流) $O...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值