DP22 堆盒子问题 Box Stacking Problem @geeksforgeeks

本文介绍了一种基于动态规划的三维盒子堆叠问题解决方案。该问题要求在遵循特定尺寸限制条件下,通过旋转和堆叠不同类型的三维盒子来构建尽可能高的堆叠。文章详细解释了算法步骤,并提供了一个Java实现示例。

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

You are given a set of n types of rectangular 3-D boxes, where the i^th box has height h(i), width w(i) and depth d(i) (all real numbers). You want to create a stack of boxes which is as tall as possible, but you can only stack a box on top of another box if the dimensions of the 2-D base of the lower box are each strictly larger than those of the 2-D base of the higher box. Of course, you can rotate a box so that any side functions as its base. It is also allowable to use multiple instances of the same type of box.

Source: http://people.csail.mit.edu/bdean/6.046/dp/. The link also has video for explanation of solution.

The Box Stacking problem is a variation of LIS problem. We need to build a maximum height stack.

Following are the key points to note in the problem statement:
1) A box can be placed on top of another box only if both width and depth of the upper placed box are smaller than width and depth of the lower box respectively.
2) We can rotate boxes. For example, if there is a box with dimensions {1x2x3} where 1 is height, 2×3 is base, then there can be three possibilities, {1x2x3}, {2x1x3} and {3x1x2}.
3) We can use multiple instances of boxes. What it means is, we can have two different rotations of a box as part of our maximum height stack.

Following is the solution based on DP solution of LIS problem.

1) Generate all 3 rotations of all boxes. The size of rotation array becomes 3 times the size of original array. For simplicity, we consider depth as always smaller than or equal to width.

2) Sort the above generated 3n boxes in decreasing order of base area.

3) After sorting the boxes, the problem is same as LIS with following optimal substructure property.
MSH(i) = Maximum possible Stack Height with box i at top of stack
MSH(i) = { Max ( MSH(j) ) + height(i) } where j < i and width(j) > width(i) and depth(j) > depth(i).
If there is no such j then MSH(i) = height(i)

4) To get overall maximum height, we return max(MSH(i)) where 0 < i < n


3维的就确定下两维(底面积),根据底面积排序,然后找高度的LDS

package DP;

import java.util.Arrays;
import java.util.Comparator;

public class BoxStacking {

	public static void main(String[] args) {
		Box[] A = new Box[4];
		A[0] = new Box(4,6,7);
		A[1] = new Box(1,2,3);
		A[2] = new Box(4,5,6);
		A[3] = new Box(10,12,32);
		int n = A.length;
		System.out.println(maxStackHeight(A, n));
	}	
	
	// Time Complexity: O(n^2) Auxiliary Space: O(n)
	public static int maxStackHeight(Box[] A, int n){
		/* Create an array of all rotations of given boxes
	      For example, for a box {1, 2, 3}, we consider three
	      instances{{1, 2, 3}, {2, 1, 3}, {3, 1, 2}} */
		Box[] rot = new Box[3*n];
		int index = 0;
		for(int i=0; i<n; i++){
			rot[index] = A[i];		// Copy the original box
			index++;
			
			rot[index] = new Box();		// First rotation of box
			rot[index].h = A[i].w;
			rot[index].d = Math.max(A[i].h, A[i].d);
			rot[index].w = Math.min(A[i].h, A[i].d);
			index++;
			
			rot[index] = new Box();		// Second rotation of box
			rot[index].h = A[i].d;
			rot[index].d = Math.max(A[i].h, A[i].w);
			rot[index].w = Math.min(A[i].h, A[i].w);
			index++;
		}
		
		n = 3*n;		// Now the number of boxes is 3n
		
		/* Sort the array ‘rot[]‘ in decreasing order, using library
	      function for quick sort */
		Arrays.sort(rot, new Comparator<Box>() {
			@Override
			public int compare(Box o1, Box o2) {		// 按底面积递减排序
				return (o2.d*o2.w) - (o1.d*o1.w);
			}
		});
		
		/* Initialize msh values for all indexes 
	      msh[i] –> Maximum possible Stack Height with box i on top */
		int[] msh = new int[n];
		for(int i=0; i<n; i++){
			msh[i] = rot[i].h;
		}
		
		/* Compute optimized msh values in bottom up manner */
		for(int i=1; i<n; i++){
			for(int j=0; j<i; j++){
				if(rot[i].w<rot[j].w && rot[i].d<rot[j].d){
					msh[i] = Math.max(msh[i], msh[j]+rot[i].h);
				}
			}
		}
		
		/* Pick maximum of all msh values */
		int max = 0;
		for(int i=0; i<n; i++){
			max = Math.max(max, msh[i]);
		}
		return max;
	}

	public static class Box{
		int h, w, d;		// h –> height, w –> width, d –> depth
		// for simplicity of solution, always keep w <= d
		public Box(){
		}
		public Box(int h_, int w_, int d_){
			h = h_;
			w = w_;
			d = d_;
		}
	}
}

http://www.geeksforgeeks.org/dynamic-programming-set-21-box-stacking-problem/

http://people.csail.mit.edu/bdean/6.046/dp/

### Stacking叠的创新方法与应用 Stacking是一种强大的集成学习技术,其核心思想在于利用一个次级学习器来综合多个初级学习器的结果[^1]。这种方法不仅能够提升预测性能,还能有效结合不同模型的优点。以下是关于Stacking的一些创新方法及其在实际中的应用场景: #### 1. 多层Stacking 传统的Stacking通常只涉及一层次级学习器,而多层Stacking则引入了更多的层次结构。每一层都可以看作是一个新的特征提取过程,上一层的输出作为下一层的输入。这种设计可以进一步挖掘数据中的复杂模式并提高模型的表现。 ```python from sklearn.linear_model import LogisticRegression from sklearn.svm import SVC from sklearn.tree import DecisionTreeClassifier from mlxtend.classifier import StackingCVClassifier # 定义基础分类器 clf1 = LogisticRegression() clf2 = SVC(probability=True) clf3 = DecisionTreeClassifier() # 使用逻辑回归作为元分类器 meta_clf = LogisticRegression() # 构建两层Stacking模型 stacking_classifier = StackingCVClassifier(classifiers=[clf1, clf2], meta_classifier=meta_clf, use_probas=True) # 训练模型 stacking_classifier.fit(X_train, y_train) ``` #### 2. 自适应Stacking 自适应Stacking允许动态调整各初级学习器的权重或参数配置,从而更好地适配特定的数据分布特性。这一改进可以通过优化算法实现,例如基于梯度下降或其他启发式搜索机制自动寻找最佳组合方式。 #### 3. 面向时间序列的Stacking 对于时间序列预测任务,传统Stacking可能无法充分利用时间维度上的依赖关系。因此提出了针对此类场景定制化的解决方案——即考虑历史信息以及未来趋势变化的影响,在构建次级学习器时加入额外的时间特征工程步骤。 #### 4. 跨模态Stacking 当处理多媒体数据分析(如图像、文本联合分析)等问题时,跨模态Stacking提供了一种有效的框架。它通过分别训练适用于不同类型数据源的专家网络,并最终由统一的高层模块完成决策整合工作。 #### 实际案例分享 - **金融领域**: 在信用评分评估过程中采用Stacking技术融合多种统计学指标计算结果与深度神经网络表达能力,显著提高了风险识别精度。 - **医疗健康**: 结合基因组测序技术和临床诊断记录建立混合型预测体系,借助Stacking实现了个性化治疗方案推荐功能。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值