UVALive - 4794 (状压枚举子集)

本文探讨了一个特定的切割问题:如何通过横竖切割将x*y大小的巧克力分成n块,每块面积分别为a[i]。采用状压DP算法,利用记忆化搜索优化递归过程,实现高效求解。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题意:给你一块x*y的巧克力,n个面积a[i],每次只能横着或者竖着切一次,问你是否能切出来n块面积为a[i]的巧克力。

思路:n为15,可以想到状压所有状态,然后记忆化搜索,设立状态d[x][s],sum[s]表示集合为s的巧克力面积和就是当前要切的巧克力的面积,x表示当前要切的巧克力的长和宽的最小值,那么我们就知道当前巧克力的长和宽,当前状态向下转移时有两种方式,一种是把长分为两部分,一种是把宽分为两部分,dp[x][s]就是当前状态下是否能切成功。我们枚举s的子集,分别对两种方式记忆化搜索即可。

  

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int a[20], sum[(1<<15)+10], n,x,y;
bool vis[110][(1<<15)+10], f[110][(1<<15)+10];
int bitcount(int x)
{
	return x==0?0:bitcount(x>>1)+(x&1);
}
int dfs(int l,int s)
{
	if(vis[l][s]) return f[l][s];
	vis[l][s]=1;
	if(bitcount(s)==1) return f[l][s] = 1;
	int r=sum[s]/l;
	for(int s0=(s-1)&s;s0;s0=(s0-1)&s)		//枚举子集 
	{
		int s1=s-s0;		//补集 
		if((sum[s0]%l==0)&&dfs(min(sum[s0]/l,l),s0)&&dfs(min(sum[s1]/l,l),s1))		//把l分为两部分是否可行 
		return f[l][s]=1;
		if((sum[s0]%r==0)&&dfs(min(sum[s0]/r,r),s0)&&dfs(min(sum[s1]/r,r),s1))		//把r分为两部分是否可行
		return f[l][s]=1;
	}
	return f[l][s]=0;//不可行 
}
int main()
{
	int cas=1;
	while(scanf("%d",&n)&&n)
	{
		memset(vis,0,sizeof(vis));
		memset(f,0,sizeof(f));
		scanf("%d%d",&x,&y);
		int p=0;
		for(int i=0;i<n;i++)
		{
			scanf("%d",&a[i]);
			p+=a[i];
		}
		for(int i=0;i<(1<<n);i++)
		{
			sum[i]=0;
			for(int j=0;j<n;j++)
			if(i&(1<<j)) sum[i]+=a[j];
		}
		int ans=0;
		if(p!=x*y)
			ans=0;
		else ans=dfs(min(x,y),(1<<n)-1);
		if(ans) printf("Case %d: Yes\n",cas++);
		else printf("Case %d: No\n",cas++);
	}
	return 0;
}

 

### 如何用编程方法生成集合的所有子集 #### 时间复杂度与基本原理 枚举子集的核心在于理解其时间复杂度以及背后的逻辑。对于一个大小为 \( n \) 的集合,其所有可能的子集数量为 \( 2^n \),这是因为每个元素都有两种态:要么属于某个子集,要么不属于该子集[^1]。 这种指数级的时间复杂度意味着,在实际应用中,通常只适合处理较小规模的数据集(例如 \( n \leq 30 \))。为了高效地生成这些子集,可以通过位运算或者递归来实现。 --- #### 方法一:基于位运算的方法 通过将整数范围内的每一个数字视为一种掩码来表示不同的子集组合。具体来说: - 假设集合中的元素编号从 0 到 \( n-1 \)- 对于任意一个介于 \( 0 \) 和 \( 2^n - 1 \) 范围内的整数 \( i \),将其转化为二进制形式,则第 \( j \)-bit 表示是否选取原集合中的第 \( j \) 号元素。 以下是 Python 实现代码: ```python def generate_subsets_bitmask(s): n = len(s) subsets = [] for mask in range(1 << n): # 遍历从 0 到 (2^n - 1) subset = [s[j] for j in range(n) if (mask & (1 << j))] subsets.append(subset) return subsets # 测试例子 example_set = ['a', 'b', 'c'] result = generate_subsets_bitmask(example_set) print(result) ``` 上述程序利用了按位操作符 `&` 来判断某一位是否被设置为 1,从而决定当前元素是否加入到对应的子集中[^3]。 --- #### 方法二:基于递归的方式 另一种常见的做法是采用分治的思想,即每次考虑下一个未决策的元素是否有资格进入当前构建过程中的部分解里去形成新的候选方案之一;最终当遍历完成整个数组之后便能够得到完整的幂集结构。 下面是 C++ 版本的一个简单示范: ```cpp #include <iostream> #include <vector> using namespace std; void findSubsets(int index, vector<int> currentSet, const vector<int>& originalSet, vector<vector<int>>& allSubsets){ if(index == originalSet.size()){ allSubsets.push_back(currentSet); return; } // 不选择当前位置上的元素 findSubsets(index + 1, currentSet, originalSet, allSubsets); // 选择当前位置上的元素 currentSet.push_back(originalSet[index]); findSubsets(index + 1, currentSet, originalSet, allSubsets); } int main(){ vector<int> set = {1, 2, 3}; vector<vector<int>> result; findSubsets(0, {}, set, result); cout << "All Subsets:" << endl; for(auto s : result){ cout << "{ "; for(auto elem : s){ cout << elem << " "; } cout << "}" << endl; } return 0; } ``` 此版本展示了如何通过函数调用来模拟树形搜索路径,并逐步累积每条分支的结果直到叶节点处收集完毕为止[^2]。 --- #### 复杂度分析 无论采取哪种方式实现,由于都需要访问全部潜在可能性因此总体计算量必然达到 \( O(2^n * k) \),其中 \( k \) 是平均单个输出所需的操作次数(比如拷贝列表等额外开销),而空间消耗则取决于所使用的数据存储策略及其最大深度限制条件下的栈帧需求情况。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值