POJ 1011 Sticks

最新推荐文章于 2022-07-05 21:10:00 发布
最新推荐文章于 2022-07-05 21:10:00 发布
阅读量558 收藏
点赞数
分类专栏： - 深搜 POJ ####### 搜索 ######## 文章标签： DFS 剪枝 贪心
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013569656/article/details/24328285
版权

题目大意：

        乔治将几根长度一样的木棍随机砍断，得到若干长度随机的小木棍，现在他想把这些小木棍拼回去，但是已经忘记掉原木棍的长度和根数，现在请你编程确定原木棍最短为多少。

        现有多个测例，每个测例都给出随机长度小木棍的数量n（n不超过64），并给出每根小木棍的长度（小木棍超度不超过50），要求输出可能的原木棍的最小长度，以n = 0作为输入的结束。

题目链接

注释代码：

/*           
 * Problem ID : POJ 1011 Sticks
 * Author     : Lirx.t.Una           
 * Language   : GCC          
 * Run Time   : 0 ms           
 * Run Memory : 360 KB           
*/ 

#pragma GCC optimize("O2")

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#define	TRUE		1
#define	FALSE		0

//maximum number of sticks
//木棍的最大数量
#define	MAXSTKN		64

typedef	char	BOOL;

short	len[MAXSTKN];//每条木棍的长度，从下标0计
BOOL	usd[MAXSTKN];//used，表示第i号棍子是否使用过

int
fcmp(const void *a, const void *b) {
	
	return *(short *)b - *(short *)a;
}

//思路：由于每一个目标段中都至少包含一条小木棍
//因此目标段的最小长度至少为小木棍的最大长度
//因此可以先将小木棍按照长度从大到小排序
//然后在贪心选择的基础上DFS

BOOL
dfs( int ncplt, short cl, int cur, int ns, short sl, int n ) {
	//completed number，已经拼好的棍子的数量
	//current length，目前已经拼凑了多长（是指一个段里）
	//current stick，当前正扫描的木棍的编号
	//segment number，目标段的个数
	//segment length，目标段的长度
	//totol stick number，小木棍的总数量
	
	if ( ncplt == ns )//如果已经拼完所有目标段则成功退出
		return TRUE;
	
	for ( ; cur < n; cur++ ) {//否则就从当前木棍开始检查
		
		//！！！剪枝1
		//如果当前木棍已被使用过了
		//或者是和已经拼好的长度相加超过目标段长
		//则直接跳过
		if ( usd[cur] || cl + len[cur] > sl )
			continue;

		//否则就可以标记为使用过		
		usd[cur] = TRUE;
		//否则就可以标记为使用过，接下来做相应的检查
		
		//否则就可以标记为使用过，接下来做相应的检查
		if ( cl + len[cur] == sl ) {
			
			//则继续搜索
			//此时因为cl和len[cur]已经拼好了一个完整的段
			//因此进入下一层搜索时拼好的数量就是ncplt+1了
			//并且拼好的长度清零
			//并且从头开始扫描
			if ( dfs( ncplt + 1, 0, 0, ns, sl, n ) )
				return TRUE;
			
			//！！！剪枝2
			//如果剩下的所有小木棍无法完成目标
			//则表示当前方案失败
			//因为若不使用len[cur]，但是为了完成目标
			  //接下来必定要找到能和cl组成完整段的小木棍
			  //即使能找到，那这些和cl组成完整段的小木棍的效果
			  //和len[cur]是一样的，所以就算这一层中不适用len[cur]
			  //后面的搜索同样是不成功的
			//因此这里需要剪枝，不能往下搜索了
			return usd[cur] = FALSE;
		}
		
		//接下来就是cl + len[cur] < sl的情况了

		//继续下一层搜索，只不过拼好的长度为cl + len[cur]了
		//由于当前还没有拼完一段目标段，因此还是ncplt
		//并且得从cur + 1的位置继续扫描
		//因为len是从大到小排序过的（方便贪心选择）
		if ( dfs( ncplt, cl + len[cur], cur + 1, ns, sl, n ) )
			return TRUE;
		
		//如果不成功，则有可能替换len[cur]
		usd[cur] = FALSE;
		//！！！剪枝3
		//如果cl = 0，则表示拿len[cur]和其它剩下的木棍凑，凑不出目标
		//因此只能失败退出
		if ( !cl )
			return FALSE;
		
		//！！！剪枝4
		//否则就表示cl和len[cur]组合在一起是不能和剩下的小木棍凑出目标
		//这就意味着cl和其它len组合可能凑出目标
		//因此尝试换其它len和cl组合
		//但是得避免后面重复测试和len[cur]一样长的木棍
		while ( cur + 1 < n && len[cur] == len[cur + 1] )
			cur++;
	}
	
	return FALSE;//所有小木棍都检测完仍然凑不出
}

int
main() {
	
	int		n;//木棍数量
	
	short	tl;//totol length，小木棍总长
	short	ns;//number of segment，目标段数量
	short	sl;//length of segment，目标段长度（sl = tl / ns） 
	
	BOOL	cd;//can be done，用于标志当前sl能否被成功凑出
	
	int		i;
	
	while ( scanf("%d", &n), n ) {
		
		for ( tl = 0, i = 0; i < n; i++ ) {
			
			scanf("%d", len + i);
			tl += len[i];
		}
		qsort(len, n, sizeof(short), &fcmp);
		
		cd  = FALSE;//初始化
		//！！！剪枝5
		//不用sl从len[0]一直++到tl的方式进行搜索
		//因为最多只能被分为tl / len[0]段，最少分为1段
		//用段数来扫描比直接用段长++扫描的方式少很多判( tl % sl ) == 0的环节
		for ( ns = tl / *len; ns >= 2; ns-- )//！！！剪枝6，如果ns = 2也不行，则ns = 1是必然成立的
			                                 //因此不用麻烦地对ns = 1也进行搜索了！！！
			if ( !( tl % ns ) ) {
				
				memset(usd, FALSE, sizeof(usd));
				if ( dfs( 0, 0, 0, ns, sl = tl / ns, n ) ) {
					
					cd = TRUE;
					break;
				}
			}
			
		if ( cd )
			printf("%d\n", sl);
		else
			printf("%d\n", tl);
	}
	
	return 0;
}

无注释代码：

#pragma GCC optimize("O2")

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#define	TRUE		1
#define	FALSE		0

#define	MAXSTKN		64

typedef	char	BOOL;

short	len[MAXSTKN];
BOOL	usd[MAXSTKN];

int
fcmp(const void *a, const void *b) {

	return *(short *)b - *(short *)a;
}

BOOL
dfs( int ncplt, short cl, int cur, int ns, short sl, int n ) {

	if ( ncplt == ns )
		return TRUE;

	for ( ; cur < n; cur++ ) {
	
		if ( usd[cur] || cl + len[cur] > sl )
			continue;

		usd[cur] = TRUE;

		if ( cl + len[cur] == sl ) {
		
			if ( dfs( ncplt + 1, 0, 0, ns, sl, n ) )
				return TRUE;
			
			return usd[cur] = FALSE;
		}

		if ( dfs( ncplt, cl + len[cur], cur + 1, ns, sl, n ) )
			return TRUE;

		usd[cur] = FALSE;
		if ( !cl )
			return FALSE;

		while ( cur + 1 < n && len[cur] == len[cur + 1] )
			cur++;
	}
	
	return FALSE;
}

int
main() {
	
	int		n;
	
	short	tl;
	short	ns;
	short	sl;
	
	BOOL	cd;
	
	int		i;
	
	while ( scanf("%d", &n), n ) {
		
		for ( tl = 0, i = 0; i < n; i++ ) {
			
			scanf("%d", len + i);
			tl += len[i];
		}
		qsort(len, n, sizeof(short), &fcmp);
		
		cd  = FALSE;
		for ( ns = tl / *len; ns >= 2; ns-- )
			if ( !( tl % ns ) ) {
				
				memset(usd, FALSE, sizeof(usd));
				if ( dfs( 0, 0, 0, ns, sl = tl / ns, n ) ) {
					
					cd = TRUE;
					break;
				}
			}
			
		if ( cd )
			printf("%d\n", sl);
		else
			printf("%d\n", tl);
	}
	
	return 0;
}

优化：

注释代码：

/*           
 * Problem ID : POJ 1011 Sticks
 * Author     : Lirx.t.Una           
 * Language   : C++          
 * Run Time   : 0 ms           
 * Run Memory : 136 KB           
*/ 

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>

#define	MAXN	64

using namespace std;

char	len[MAXN];
bool	usd[MAXN];

int		n;//小棍个数
int		len_seg;//length of each segment，目标段长度

bool
dfs( int n_rst, int seg_len_rst, int cur_i ) {
	//number of rest sticks，剩下没有拼完的小棍数
	//rest segment length，目标段还有多少没被拼完
	//current ith sticks，当前检测到第cur_i号小棍（下标从0开始）
	
	if ( !n_rst && !seg_len_rst ) return true;//全部拼完
	
	if ( !seg_len_rst ) {//小棍没用完，但是当前目标段为0
		//表示刚拼完一个目标段，还需用剩下的小棍拼目标端
		
		seg_len_rst = len_seg;//初始化当前目标段待拼的剩余长度
		cur_i = 0;//按照目标端从左到右小棍长度降低的规则从头开始检测小棍
	}
	
	for ( ; cur_i < n; cur_i++ )
		if ( !usd[cur_i] && len[cur_i] <= seg_len_rst ) {//检测的小棍不能大于当前剩余目标段长
			
			usd[cur_i] = true;//符合要求，先试探性使用一下该小棍
			                                               
			                                               //目标段中小棍从左到右长度递减
			                                               //因此一下次搜索cur_i必须前进一格
			if ( dfs( n_rst - 1, seg_len_rst - len[cur_i], cur_i + 1 ) ) return true;
			usd[cur_i] = false;//搜索失败，退还该木棍       //剪枝1
			
			                      
			     //如果当前小木棍是当前    //如果当前小木棍是当前
			     //目标段的头              //目标段的尾
			//则表示是上一次检测的小木棍有问题，不用继续替换当前小木棍，因此直接失败退出
			if ( seg_len_rst == len_seg || seg_len_rst == len[cur_i] ) return false;
                         //剪枝2                   //剪枝3

			                         //虽然当前小木棍既不是当前目标段的头也不是尾
			                         //但反正是失败了，因此在接下来的搜索中排除和它一样长的小木棍
			while ( cur_i + 1 < n && len[cur_i] == len[cur_i + 1] ) cur_i++;
		}                                    //剪枝4
		
	return false;//一直都没搜出答案，失败退出
}

bool
fcmp( char a, char b ) {
	
	return a > b;
}

int
main() {
	
	int		len_tot;//所有小棍总长度
	int		n_seg;//假设的目标段的个数
	
	int		i;
	
	bool	done;
	
	while ( scanf("%d", &n), n ) {
		
		len_tot = 0;
		for ( i = 0; i < n; i++ ) {
			
			scanf("%d", len + i);
			len_tot += len[i];
		}
		sort(len, len + n, fcmp);
		
		done = false;
		for ( n_seg = len_tot / *len; n_seg > 1; n_seg-- )
			if ( !( len_tot % n_seg ) ) {
				
				memset(usd, 0, sizeof(usd));
				if ( dfs( n, len_seg = len_tot / n_seg, 0 ) ) {
					
					done = true;
					break;
				}
			}
			
		if ( done ) printf("%d\n", len_seg);
		else printf("%d\n", len_tot);
	}
	
	return 0;
}
无注释代码： 

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>

#define	MAXN	64

using namespace std;

char	len[MAXN];
bool	usd[MAXN];

int		n;
int		len_seg;

bool
dfs( int n_rst, int seg_len_rst, int cur_i ) {

	if ( !n_rst && !seg_len_rst ) return true;

	if ( !seg_len_rst ) {
		
		seg_len_rst = len_seg;
		cur_i = 0;
	}

	for ( ; cur_i < n; cur_i++ )
		if ( !usd[cur_i] && len[cur_i] <= seg_len_rst ) {
		
			usd[cur_i] = true;
			if ( dfs( n_rst - 1, seg_len_rst - len[cur_i], cur_i + 1 ) ) return true;
			usd[cur_i] = false;

			if ( seg_len_rst == len_seg || seg_len_rst == len[cur_i] ) return false;
			while ( cur_i + 1 < n && len[cur_i] == len[cur_i + 1] ) cur_i++;
		}

	return false;
}

bool
fcmp( char a, char b ) {

	return a > b;
}

int
main() {

	int		len_tot;
	int		n_seg;

	int		i;

	bool	done;

	while ( scanf("%d", &n), n ) {
	
		len_tot = 0;
		for ( i = 0; i < n; i++ ) {
		
			scanf("%d", len + i);
			len_tot += len[i];
		}
		sort(len, len + n, fcmp);

		done = false;
		for ( n_seg = len_tot / *len; n_seg > 1; n_seg-- )
			if ( !( len_tot % n_seg ) ) {
			
				memset(usd, 0, sizeof(usd));
				if ( dfs( n, len_seg = len_tot / n_seg, 0 ) ) {
				
					done = true;
					break;
				}
			}

		if ( done ) printf("%d\n", len_seg);
		else printf("%d\n", len_tot);
	}

	return 0;
}
单词解释：

randomly：adv, 随机地，任意地

__Lirx_t_Una__
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
poj(1011)——Sticks（经典的dfs+剪枝）
ACM_hades的梦想之路
07-26 5393
题目的大致意思是： 现在有n根木棍，然后需要把它们拼成同样长度的木棍，问满足这个条件的最短的长度是多少？ 想法嘛：那肯定是dfs把长度搜一遍就好，但问题的关键是这里会超时。那么就要用到剪枝的原理了。 以下部分是来自于pku的gw老师说哒 1）不要在同一个位置多次尝试相同长度的木棒（在某一次拼接时选择长度为s的木棒导致拼接失败，则在同一位置尝试下一根木棒时，要跳过所有长度为s的木棒） 2）
poj 1011 sticks
zerooffdate的专栏
08-11 208
简单来说就是有很多长度相同的木棍，被切分为不同长度，然后要求重新拼起来，看拼起来之后，长度相同的木棍，最短是多少长度。 这里看到几个问题 拼起来之后长度应该是一样的 从条件一推断，最段长度minL应该满足total_len % minL == 0，即最小长度可以整除总长度 从结论二可以推断，拼好之后最短长度应该大于所有木棍里面最长那根木棍 同样从条件一推断，最大长度是所有木棍的总长度，也...
qsort()中cmp函数
m0_51627418的博客
11-10 1871
基本形式： int cmp(const void *a ,const void *b); 分析一下这个基本形式： 函数返回值为 int 形参为两个const void *，意味着这两个参数是const void *类型，也就是一个指针，const代表这个指针所指向的内存单元的值不能被改变。void *，为一个无类型指针，既可以通过强制类型转换，使其转换为任意类型的指针，甚至直接取指向的数据值。 使用方法 对于qsort中 int cmp(const void *a ,const void *b) { .
poj-sticks
机器学习，数据挖掘算法爱好者
05-04 191
  参考自：这位博主 描述 George took sticks of the same length and cut them randomly until all parts became at most 50 units long. Now he wants to return sticks to the original state, but he forgot how many s...
Poj Sticks(木棒) DFS+剪枝
xinxinqqt的专栏
04-02 644
描述 乔治拿来一组等长的木棒，将它们随机地裁断，使得每一节木棍的长度都不超过50个长度单位。然后他又想把这些木棍恢复到为裁截前的状态，但忘记了初始时有多少木棒以及木棒的初始长度。请你设计一个程序，帮助乔治计算木棒的可能最小长度。每一节木棍的长度都用大于零的整数表示。 输入 输入包含多组数据，每组数据包括两行。第一行是一个不超过64的整数，表示砍断之后共有多少节木棍。第二行是截断以后，所得到的
poj(1011)——Sticks（dfs+剪枝）
点点滴滴
09-08 279
George took sticks of the same length and cut them randomly until all parts became at most 50 units long. Now he wants to return sticks to the original state, but he forgot how many sticks he had orig...
POJ1011-Sticks
07-31
【标题】"POJ1011 - Sticks" 是一个经典的计算机编程竞赛题目，源自北京大学的在线评测系统POJ（PKU Online Judge）。这个题目挑战程序员解决与几何图形和数学逻辑相关的问题。 【描述】该题目的核心是求解在二维...
POJ 1011_sticks.rar
02-18
详细解释 ，既有源代码又有书面文字解释，ppt，在VC6上完成
poj 2452 Sticks Problem.md
11-17
poj 2452 Sticks Problem.md
cpp代码-2.24.1 poj 1011
07-16
【标题】cpp代码-2.24.1 poj 1011 这篇代码是针对POJ（普林斯顿在线判题系统）中的1011题目的解决方案，使用了C++编程语言。POJ是一个知名的在线编程竞赛平台，它为参赛者提供了各种算法题目以提升编程和算法能力。...
Sticks（迭代搜索）
zheng159987的博客
07-05 293
题意：（经典的迭代dfs搜索）有许多未知数目的相同木棍被“随意”的切割分成很多段，让你寻找出棍子可能存在的最小长度思路：通过题意理解，可能出现多种匹配的方法，最先想到的是进行dfs，但是对于此题最基本的dfs超时，这就需要我们使用迭代搜索，类似有bfs但是实则是一种更省时间的dfs来操作通过访问数组中储存的被切过得棍子的长度来不断重建棍子，直到找到最终的棍子最佳长度和数目代码：...
经典剪枝算法的例题——Sticks详细注释版
SJ2050的博客
06-10 5983
这题听说是道十分经典的剪枝算的题目，不要问我剪枝是什么，我也不知道，反正我只知道用到了深度搜索我参考了好多资料才悟懂，然后我发现网上的哪些大神原理讲的很明白，但代码没多少注释，看的很懵X，于是我抄起VS写了个详细注释版，真的很详细，史上最详细，全宇宙最详细，就这么自信，不信你看，看不懂你咬我。/*-------------------------------------------- * ...
木棍问题
weixin_34114823的博客
11-06 459
Description 乔治拿来一组等长的木棒，将它们随机地砍断，使得每一节木棍的长度都不超过50个长度单位。然后他又想把这些木棍恢复到为裁截前的状态，但忘记了初始时有多少木棒以及木棒的初始长度。请你设计一个程序，帮助乔治计算木棒的可能最小长度。每一节木棍的长度都用大于零的整数表示。 Input 输入包含多组数据，每组数据包括两行。第一行是一个不超过64的整数，表示砍断...
UVA 307 - Sticks
Bingo
08-24 1622
#include #include #include using namespace std; int n, top, sum, Max, vis[105], part[105]; int cmp(int a, int b) { return a > b; } bool DFS(int pos, int cnt, int lenth) { if (cnt == top) ret
poj sticks
weixin_34198881的博客
05-21 105
2019独角兽企业重金招聘Python工程师标准>>> ...
Sticks(经典深搜+剪枝)
Cybenko
06-09 3080
#include &lt;iostream&gt; #include &lt;algorithm&gt; using namespace std; //total能组成的木棒的组数,l:组成的木棒的长度 int total,l; //num:输入的整数，sum：总长度 int num,sum; typedef struct { int length;//木棒的长度 bool ma...
Sticks
Accepted ALL lve
03-18 978
Description George took sticks of the same length and cut them randomly until all parts became at most 50 units long. Now he wants to return sticks to the original state, but he forgot how many sti
poj Divisibility
最新发布
09-12
POJ Divisibility是一个编程题，要求编写一个程序来确定一系列整数是否可被K整除。输入文件的第一行包含两个整数N和K，用一个空格分隔。第二行包含一系列N个整数，以空格分隔。每个整数的绝对值不大于10000。在输出...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值