Box Stacking Problem

Problem statement

You are given three integer arrays of size N, which represent the height, width and length of N boxes, respectively.

Your task is to stack the boxes on each other such that the height should be maximum, and you have to return the height.

To put one box on top of another box, the dimension of the top box should be strictly less than the dimension of the bottom box, which means the length and width of the top boxes should be strictly smaller than the bottom box.

We can have multiple instances of a box, which means we can rotate the box as we want and then use it as another box. We know there are six faces of a cuboid. We can have six instances of a box, but there will be only three unique instances, so indirectly, we will have 3*N boxes with different dimensions, and we have to find the maximum height.

Approach:

We will use a dynamic programming approach here to solve this problem. We will sort the array based on its width, and then we will try to find out the longest Increasing Subsequence (LIS) to get the maximum height.

Java Example:

import java.util.*;
public class Main{
    public static class Pair implements Comparable<Pair>{
        int h;
        int w;
        int l;
        Pair(int h,int w,int l){
            this.h=h;
            this.w=w;
            this.l=l;
        }
        public int compareTo(Pair o){
            if(this.w==o.w)
            return o.l-this.l;
            return this.w-o.w;
        }
    }
    public static void main(String[] args){
        int[] height={4,1,4,10};
        int[] width={6,2,5,12};
        int[] length={7,3,6,32};
        
        System.out.println(getHeight(height,width,length));
    }
    public static int getHeight(int[] height,int[] width,int[] length){
        ArrayList<Pair> arr = new ArrayList<>();
        for(int i=0;i<height.length;i++){
            if(width[i]<length[i]){
                arr.add(new Pair(height[i],width[i],length[i]));
            }else{
                arr.add(new Pair(height[i],length[i],width[i]));
            }
            
            if(height[i]<length[i]){
                 arr.add(new Pair(width[i],height[i],length[i]));
            }else{
                arr.add(new Pair(width[i],length[i],height[i]));
            }
            
            if(height[i]<width[i]){
                arr.add(new Pair(length[i],height[i],width[i]));
            }else{
                arr.add(new Pair(length[i],width[i],height[i]));
            }
        }
        Collections.sort(arr);
        int[] dp=new int[arr.size()];
        int ans=0;
        for(int i=0;i<dp.length;i++){
            if(i==0){
                dp[i]=arr.get(i).h;
                ans=Math.max(ans,dp[i]);
                continue;
            }
            int max=0;
            for(int j=0;j<i;j++){
                if(arr.get(j).l< arr.get(i).l && arr.get(j).w<arr.get(i).w)
                max=Math.max(max,dp[j]);
            }
            dp[i]=arr.get(i).h+max;
            ans=Math.max(ans,dp[i]);
        }
        return ans;
    }
   
}

Output:

Explanation:

In the above code, we are given three different arrays representing the height, width and length of four different boxes. As we know, we can rotate the box to create its instance, so indirectly, we will have 12 options or 12 boxes for this problem.

We will create the pair class to store the dimensions and write the comparator for our ArrayList. We will iterate over the array, and we will check three cases for each box to get its three instances.

Case 1: If the width of the box is smaller than the length, then we will add as dimension as it is. Otherwise, we will swap width with length and add it as a new box.

Case2: If the height of the box is smaller than the length, then we will swap the height and width; otherwise, we will swap the width with height and again height with length and add it as a new box.

Case3: If the height of the box is smaller than the width, then we will swap width and length and then length and height to get the new dimension box. Otherwise, we will swap height with length and add it as a new box.

After adding all the relevant boxes to ArrayList, we will sort them in ascending order according to their widths.

We will use the LIS (Longest Increasing Subsequence) technique to get the solution. We will create the dp array of size the same as ArrayList.

dp[i] will store the maximum height we can get by stacking the box from 0 to i-1 if the base of the stack is the i^th box.

If it is the first box, then the maximum height will be its height so that it will be a base case.

Now for the rest of the boxes, we will loop from 0 to i-1 and get the maximum value of dp[j], and we will add the maximum value and height of the i^th box to get the maximum size of the box.

The maximum value of the dp array will be our answer.

In the above example, we have four boxes so we will create its 12 instances as follows: