poj_3436

最新推荐文章于 2020-08-20 17:05:47 发布
原创 最新推荐文章于 2020-08-20 17:05:47 发布 · 331 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#最大流

源地址：http://poj.org/problem?id=3436

题目大意就是有n个机器，然后每个机器有2*p+1个参数，第一个参数是这个机器能够处理任务的数量，后p个是这个机器所需要的原料，分别是0,1,2 0代表这个材料不能有，1代表这个材料必须有，2代表这个材料可选，再后p个是该机器生产的产品，0表示不能生产这种原料，1表示能生产。问你怎么安排生产线才能生产最多的东西(这种东西包含所有的原料)，并且输出必须相连的两台机器的数量和具体情况(两台机器的编号以及从这流过的最大生产量)。

最大流算法。主要是建图的过程。

搞一个源点和汇点，即可看做一条生产线的开始和结尾。从开始的话，那么我们肯定是要那种不需要任何原料的机器，因为刚开始我们也没有任何原料。从题中可知，就是前p个输入中不含1的那种机器，将他们与源点相连，容量就是它能够处理的数量。然后对于那种能生产出全部p种东西的(即后p个全为1)机器，我们将它与汇点相连，因为它包含所有的材料，即能生产出完整的东西(也就是题目要求的)。接着连接产出与所需原料一一对应的两台机器，即一台机器的产出能够提供给另外一台机器当做原料。

图建好以后，我们就用EK算法来求一次最大流。题目还要求输出必须相连的两台机器，那么就是那种在求完最大流后边的权值变小的那些，流过这两台机器的最大生产量就是前后权值的差。

不过我刚开始用了一次dfs来求最大流，而不是用EK算法，好像就不行，试过一个别人给的例子，确实不对，但是不清楚哪里出了问题，还请看到的大神们指教，感谢~

错误代码：

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<limits.h>
#include<map>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff
#define FOR(i,a) for((i)=0;i<(a);(i)++)
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,c)scanf("%d%d%d",&a,&b,&c)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
const double PI=acos(-1.0);
template<class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<class T> T lcm(T a,T b){return a/gcd(a,b)*b;}
template<class T> inline T Min(T a,T b){return a<b?a:b;}
template<class T> inline T Max(T a,T b){return a>b?a:b;}
using namespace std;
#define ll __int64
int n,m;
#define Mod 1000000007
#define N 110
#define M 1000010
struct Edge{
	int from,to,cap,flow;
};
int path[N][N];
int in[N][N];
int p;
int vis[N];
int dfs(int s,int t,int f){
	if(s == t)
		return f;
	vis[s] = 1;
	for(int i=1;i<=n+1;i++){
		if(path[s][i]>0 && !vis[i]){
			int d = dfs(i,t,f<path[s][i]?f:path[s][i]);
			if(d>0){
				path[s][i] -= d;
				path[i][s] += d;
				return d;
			}
		}
	}
	return 0;
}
int FlowMax(int s,int t){
	memset(vis,0,sizeof vis);
	int flow = 0;
	int maxflow = 0;
	while((flow = dfs(s,t,INF))){
		memset(vis,0,sizeof vis);
		maxflow += flow;
	}
	return maxflow;
}
int main(){
#ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
//  freopen("out.txt","w",stdout);
#endif
    	while(sfd(p,n)!=EOF){
    		int s = 0;
    		int t = n+1;
    		for(int i=1;i<=n;i++){
    			scanf("%d",&in[i][0]);
    			  for(int j=1;j<=2*p;j++)
    				  scanf("%d",&in[i][j]);
    		}
    		memset(path,0,sizeof path);
    		for(int i=1;i<=n;i++){
    			int flag = 1;
    			for(int j=1;j<=p;j++){
    				if(in[i][j] == 1)
    					flag = 0;
    			}
    			if(flag)
    				path[s][i] = in[i][0];
    			 flag = 1;
    			for(int j=p+1;j<=2*p;j++){
    				if(in[i][j] == 0)
    					flag = 0;
    			}
    			if(flag)
    				path[i][t] = in[i][0];
    			for(int j=1;j<=n;j++){
    				flag = 1;
    				if(i == j) continue;
    				for(int k=1;k<=p;k++){
    					if(in[i][k+p]+in[j][k] == 1){
    						flag = 0;
    					}
    				}
    				if(flag)
    					path[i][j] = Min(in[i][0],in[j][0]);
    			}
    		}
//    		for(int i=0;i<=n;i++){
//    			for(int j=0;j<=n;j++)
//    				printf("%d ",path[i][j]);
//    			printf("\n");
//    		}
    		int tmp[N][N];
    		memcpy(tmp,path,sizeof(path));
    		int maxflow = FlowMax(s,t);
    		int out[N][4];
    		int e = 0;
    		for(int i=1;i<=n;i++){
    			for(int j=1;j<=n;j++){
    				if(i == j) continue;
    				if(tmp[i][j]>path[i][j]){
    					out[e][0] = i ;
    					out[e][1] = j;
    					out[e][2] = tmp[i][j] - path[i][j];
    					e++;
    				}
    			}
    		}
    		printf("%d %d\n",maxflow,e);
    		for(int i=0;i<e;i++){
    			printf("%d %d %d\n",out[i][0],out[i][1],out[i][2]);
    		}
    	}
return 0;
}

AC代码： 

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<limits.h>
#include<map>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff
#define FOR(i,a) for((i)=0;i<(a);(i)++)
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,c)scanf("%d%d%d",&a,&b,&c)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
const double PI=acos(-1.0);
template<class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<class T> T lcm(T a,T b){return a/gcd(a,b)*b;}
template<class T> inline T Min(T a,T b){return a<b?a:b;}
template<class T> inline T Max(T a,T b){return a>b?a:b;}
using namespace std;
#define ll __int64
int n,m;
#define Mod 1000000007
#define N 110
#define M 1000010
struct Edge{
	int from,to,cap,flow;
};
int path[N][N];
int in[N][N];
int p;
int vis[N];
int pre[N];
queue<int>q;
bool bfs(int s,int t){						//EK算法求最大流
	memset(pre,-1,sizeof pre);		//记录前驱节点
	memset(vis,0,sizeof vis);
	while(!q.empty())
		q.pop();
	q.push(s);
	pre[s]=s;
	vis[s]=1;
	while(!q.empty()){
		int nd = q.front();
		q.pop();
		for(int i=0;i<=n+1;i++){
			if(path[nd][i]>0&&!vis[i]){			//此路流容量>0且未被访问
				pre[i]=nd;
				vis[i]=1;
				if(i==t) return true;
				q.push(i);
			}
		}
	}
	return false;
}
int MaxFlow(int s,int t){		//s为源点，t为终点
	int flow = 0;
	while(bfs(s,t)){			//直到找不到所谓的 增广路径 时退出while语句
		int d=INF;
		for(int i=t;i!=s;i=pre[i])
			d=d<path[pre[i]][i]?d:path[pre[i]][i];			//找寻从终点到起点过程中流容量最小的一条路
		for(int i=t;i!=s;i=pre[i]){								//将从起点到终点的每一条路的容量都减小，并且增加一条反向的路
			path[pre[i]][i]-=d;
			path[i][pre[i]]+=d;
		}
		flow+=d;
	}
	return flow;
}
int main(){
#ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
//  freopen("out.txt","w",stdout);
#endif
    	while(sfd(p,n)!=EOF){
    		int s = 0;
    		int t = n+1;
    		for(int i=1;i<=n;i++){
    			scanf("%d",&in[i][0]);
    			  for(int j=1;j<=2*p;j++)
    				  scanf("%d",&in[i][j]);
    		}
    		memset(path,0,sizeof path);
    		for(int i=1;i<=n;i++){
    			int flag = 1;
    			for(int j=1;j<=p;j++){	//将输入不含1的与源点相连(即所有零件都不是必须的)，容量为该机器能处理的数量
    				if(in[i][j] == 1)
    					flag = 0;
    			}
    			if(flag)
    				path[s][i] = in[i][0];
    			 flag = 1;
    			for(int j=p+1;j<=2*p;j++){	//将输出全为1的点与汇点相连(即能生产所有产品)，容量为该机器能处理得数量
    				if(in[i][j] == 0)
    					flag = 0;
    			}
    			if(flag)
    				path[i][t] = in[i][0];
    			for(int j=1;j<=n;j++){
    				flag = 1;
    				if(i == j) continue;
    				for(int k=1;k<=p;k++){		//将某台机器(i)的输出如果能与另外一台机器(j)的输入相对应(即产出的产品能当做另外一台机器的生成原料)，那么
    					if(in[i][k+p]+in[j][k] == 1){	//将i和j相连
    						flag = 0;
    					}
    				}
    				if(flag)
    					path[i][j] = Min(in[i][0],in[j][0]);
    			}
    		}
//    		for(int i=0;i<=n;i++){
//    			for(int j=0;j<=n;j++)
//    				printf("%d ",path[i][j]);
//    			printf("\n");
//    		}
    		int tmp[N][N];
    		memcpy(tmp,path,sizeof(path));
    		int maxflow = MaxFlow(s,t);
    		int out[N][4];
    		int e = 0;
    		for(int i=1;i<=n;i++){
    			for(int j=1;j<=n;j++){
    				if(i == j) continue;
    				if(tmp[i][j]>path[i][j]){	//最大流经过的路径就是权值变小的那些边
    					out[e][0] = i ;
    					out[e][1] = j;
    					out[e][2] = tmp[i][j] - path[i][j];
    					e++;
    				}
    			}
    		}
    		printf("%d %d\n",maxflow,e);
    		for(int i=0;i<e;i++){
    			printf("%d %d %d\n",out[i][0],out[i][1],out[i][2]);
    		}
    	}
return 0;
}


ACM Computer Factory POJ - 3436 （最大流+建图+Dinic+点权与边权之间的转换）
I_have_a_world的博客
05-02 425
目录 传送门 点权转化为边权 传送门 题意：题意迷得很，最后也是看网友的才看懂。 每台计算机有p(<=10)个零件，一个公司有n(<=50)个工厂。每个工厂加工一些半成品，输入（得到）一些指定的零件，最多能够输出指定套（指定的是总输出上限，最多不能输出输入套）指定的文件。 n行，第 i 行第一个值是第 i 个工厂的总输出的上限，然后是p个数表示输入的零件，0表示一定不能有该零件，1表示一定要有该零件，2表示无所谓，接着是输出的零件，0表示有该零件，1表示没有。 题解：建图（点权转化
【题解】poj3436 ACM Computer Factory 最大流问题
翻过这座山，他们就会听到你的故事
10-11 290
题目链接 首先对每个机器拆成两个点，之间连容量为 vvv 的边。建立超级源汇点，源点连接全为0的起始点，容量INF，汇点连接全为1的终止点，容量INF，起始点与终止点之间如果配对，连上容量为INF的边。然后从源点跑最大流，反向弧容量即为所求。 采用邻接矩阵实现，代码参考大佬题解 #include&lt;cstdio&gt; #include&lt;queue&gt; #include...
POJ3436-ACM Computer Factory
07-30
北大POJ3436-ACM Computer Factory 解题报告+AC代码
POJ 3436 ACM Computer Factory
dhn37379的博客
08-13 143
这题的题目内容读起来很复杂，我来简单解释一下： 为了追求ACM比赛的公平性，所有用作ACM比赛的电脑性能是一样的，而ACM董事会专门有一条生产线来生产这样的电脑，随着比赛规模的越来越大，生产线的生产能力不能满足需要，所以说ACM董事会想要重新建造一条生产线。 生产线是全自动化的，所以需要机器来组成生产线，给定有多少中种机器，标准...
POJ 3436 最大流
java开发指南博客 【转载】
04-11 117
很羞愧啊 ， 题都没看咋懂 翻译见：http://hi.baidu.com/lewutian/blog/item/1b0709220085b7fed7cae28b.html/cmtid/87a1a0ad1aebe6064b36d60e 题解参考了：http://zhyu.me/acm/poj-3436.html，BUPT一位现役神牛的blog 每台机器分输入输出，很显然直接拆点，每个点的...
POJ - 3436 ACM Computer Factory ( 最大流 )
shinimashzi
07-11 247
POJ - 3436 题意：... 大意就是有几台机器可以把半成品加工成成品或者另外的半成品，问你最终每小时得到的最多的成品。 思路：那么由题目，这个机器出来的零件个数和另一个机器需要的零件相同时（2的位置不算），他们肯定有条线，但是这里可以看出，对机器每小时有限制数量，这是对点有限制，而不是对边有限制，所以需要拆点，我第一遍写的时候没拆，但是过了，估计数据比较弱..... 没拆点的： #
poj3436
GAUSS_CLB
02-28 1086
ACM Computer Factory Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 5574   Accepted: 1913   Special Judge Description As you know, all the computers use
POJ3436 ACM计算机工厂问题分析与解决方案
北大POJ3436-ACM Computer Factory是一个典型的计算机科学与技术领域中的算法问题，其解决方法往往涉及数据结构和算法的知识，尤其是广度优先搜索（BFS）算法及其变体。在解题报告和提供的AC代码中，我们可能会接触...
poj题目分类
02-17
* 最大流的增广路算法：例如 poj1459、poj3436。 3. 数据结构： * 串：例如 poj1035、poj3080、poj1936。 * 排序：例如 poj2388、poj2299。 * 简单并查集的应用。 * 哈希表和二分查找等高效查找法：例如 poj...
ACM Computer Factory POJ - 3436 （最大流 && 输出路径）
deerly_的博客
06-10 271
ACM Computer Factory POJ - 3436 （最大流 &amp;&amp; 输出路径） 题目链接 题目大意：有N台机器，每台机器有P部分，每部分都有各自的输入、输出规格，因此一台机器有P个输入规格，P个输出规格。每台机器有2*P+1种参数去描述：第一个参数Q：该机器的容量；接下来P个参数S：该机器各部分的输入规格；接下来P个参数D：该机器各部分的输出规格。 其中输入规格有...
POJ 3436 ACM Computer Factory(最大流)
Keaper的博客
07-11 1558
题目链接：http://poj.org/problem?id=3436 题意：题意看了好长时间。。。有一些机器来组装电脑，每台电脑有P个部分，P个部分全部组装完成才算完成。每台机器要求输入一定规格的半成品电脑，输出一定规格的电脑，每台机器有最大产出效率（每小时生产台数），要求合理安排这些机器使得总的生产效率最大。 题解：感觉是网络流，但是开始不知道怎么建模，看了别人的博客，拆点，真是巧妙，将每
POJ - 3436 ACM Computer Factory(最大流，拆点)
蒟蒻 lxw的博客
07-24 186
题目链接 题目大意：要求经过每个点的流量不超过该点承载的流量上限，求最大流 思路：将a拆成a1和a2，a1作为输入端，a2作为输出端，a1-&amp;gt;a2的边权为流量上限 #include &amp;lt;bits/stdc++.h&amp;gt; using namespace std; const int N = 2*100; const int M = N*N; int n,m,s,t,tot; ...
POJ - 3436 ACM Computer Factory （拆点+网络流）
柳予欣的三味书屋~
08-08 318
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 ...
poj3436--ACM Computer Factory(最大流，拆点dinic)
随风的专栏
12-09 1335
ACM Computer Factory Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 5501   Accepted: 1887   Special Judge Description As you know, all the computers used
poj - 3436 ACM Computer Factory（最大流+路径打印）
qq_38367681的博客
08-03 565
第一行给你P和N， P表示配件的个数， N表示机器的数量，机器可用来组装电脑，把进来时拥有的配件变成出去时的配件。 其中进入的电脑配件有三种情况：1：已配置 0：没配置 2：配置没配置都行。 从机器中出去的电脑配件有两种情况：1：已配置 0：没配置 真的恶心哦，对于我这种第一题不做出来心里难受但是它就在第一题并且这是我第二次做最大流这题那么难这么放题合适吗？不过虽然这么说，我学到了不少东西，...
POJ - 3436 ACM Computer Factory 最大流，拆点，输出路径，dinic
TheSunspot的博客
08-20 351
题目链接 POJ-3436 题意 有n个工厂加工商品，商品有m个零件，工厂有最大产能q。告诉你每个工厂能接受加工成什么样子的半成品，以及经这个工厂加工之后的产品情况，问最大能生产多少商品。 思路 看网上题解大多拆点，我这咋没拆。。 最大流题目，关键在于建图，建立超级源汇，源点向所有可以从0开始加工的工厂连边（具体到输入数据，就是输入的m个零件都为0或者2），容量为最大产能q。所有加工完毕的工厂（产出的m个零件都为1的）向汇点连边，容量为最大产能q。再枚举每个工厂A，向所有能接受这个A厂产品的工厂B连边（A厂
poj - 3436 最大流dinic + 拆点 + 输出路径
陌离将离
04-26 486
题意： 第一行给你P和N， P表示配件的个数， N表示机器的数量，机器可用来组装电脑，把进来时拥有的配件变成出去时的配件 第二行首先给你一个数， 表示这个机器一天最大的组装量， 后面是2 * P 个数             1 ~ P表示电脑进入这个机器的配件要求， 0表示不能有这个配件， 1表示必须有这个配件， 2表示可有可无；             P + 1 ~ 2 * P表示电...
POJ - 3436网络流_拆点+简单处理
mxYlulu的博客
05-31 448
写的第一道网络流。非板题。 网络流貌似核心是在于建图的处理。 POJ-3436 ：看了题解才做出来。 要求规划出合法生产线，这种形式基本就和网络流相关了。 具体题意是：有一个产品，有k个部件，给出n台机器，每台机器接受一定的半成品，输出新的半成品。最终成品是全部部件都在的成品。每个机器都有单位时间最大生产量，输入序列和输出序列，输入序列对应位是0表示不能有这个部件，1表示必须有，2表示可有可无。输...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值