[Coding Made Simple] Box Stacking

Given boxes of different dimensions, stack them on top of each other to get maximum height such that box on top has strictly less length and width than box under it.

Algorithm.

1. get all the box permutation with each permutation's length >= width; so if given n boxes, we'll get 3 * n boxes.

2. sort all the permutation boxes based the box area(length * width) in descending order.

　Because only boxes with smaller area can possibly be on top of boxes with bigger area, sorting in this way reduces this problem 

　to a problem similar with Maximum Sum Increasing Subsequence. In this problem, Maximum Height Area Increasing Boxes.

3. Create maxHeight[], maxHeight[i] is the max height possible out of box[0.....i]. To compute each maxHeight[i],  check all boxes

    whose area is bigger than boxes[i] to see if boxes[i] can be on top of boxes[j], j is from 0 to i - 1.

　If it can, update maxHeight[i] if necessary. 

4. Find the max value of maxHeight[i] as the final answer.

Similarly with Maximum Sum Increasing Subsequence, the above algorithm has overlapping subproblems issue. 

Dynamic Programming Solution.　

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

class Box {
    int length;
    int width;
    int height;
    Box(int l, int w, int h) {
        length = l;
        width = w;
        height = h;
    }
    void display() {
        System.out.println("length: " + length + " ,  " + width + " , height: " + height);
    }
}
public class BoxStacking {
    private ArrayList<Box> boxStack;
    public int maxHeightOfStackingBox(Box[] boxes) {
        boxStack = new ArrayList<Box>();
        if(boxes == null || boxes.length == 0) {
            return 0;
        }
        Box[] boxPermu = getBoxPermutation(boxes);
        int[] maxHeight = new int[boxPermu.length];
        int[] boxIdx = new int[boxPermu.length];
        for(int i = 0; i < boxPermu.length; i++) {
            maxHeight[i] = boxPermu[i].height;
            boxIdx[i] = i;
        }
        for(int i = 1; i < boxPermu.length; i++) {
            for(int j = 0; j < i; j++) {
                if(boxPermu[j].length > boxPermu[i].length && boxPermu[j].width > boxPermu[i].width) {
                    if(maxHeight[j] + boxPermu[i].height > maxHeight[i]) {
                        maxHeight[i] = maxHeight[j] + boxPermu[i].height;
                        boxIdx[i] = j;
                    }
                    
                }
            }
        }
        int maxH = 0; int topBoxIdx = -1;
        for(int i = 0; i < boxPermu.length; i++) {
            if(maxHeight[i] > maxH) {
                maxH = maxHeight[i];
                topBoxIdx = i;
            }
        }
        while(topBoxIdx != boxIdx[topBoxIdx]) {
            boxStack.add(boxPermu[topBoxIdx]);
            topBoxIdx = boxIdx[topBoxIdx];
        }
        boxStack.add(boxPermu[topBoxIdx]);
        return maxH;
    }
    private Box[] getBoxPermutation(Box[] boxes) {
        Box[] boxPermu = new Box[boxes.length * 3];
        int idx = 0;
        for(int i = 0; i < boxes.length; i++) {
            boxPermu[idx++] = new Box(Math.max(boxes[i].length, boxes[i].width), 
                                    Math.min(boxes[i].length, boxes[i].width), 
                                    boxes[i].height);
            boxPermu[idx++] = new Box(Math.max(boxes[i].length, boxes[i].height), 
                                    Math.min(boxes[i].length, boxes[i].height), 
                                    boxes[i].width);
            boxPermu[idx++] = new Box(Math.max(boxes[i].height, boxes[i].width), 
                                    Math.min(boxes[i].height, boxes[i].width), 
                                    boxes[i].length);
        }
        Comparator<Box> comp = new Comparator<Box>() {
            public int compare(Box b1, Box b2) {
                return b2.length * b2.width - b1.length * b1.width;
            }
            
        };
        Arrays.sort(boxPermu, comp);
        return boxPermu;
    }
    public static void main(String[] args) {
        Box box1 = new Box(1, 2, 4);
        Box box2 = new Box(3, 2, 5);
        Box[] boxes = {box1, box2};
        BoxStacking test = new BoxStacking();
        System.out.println(test.maxHeightOfStackingBox(boxes));
        for(int i = 0; i < test.boxStack.size(); i++) {
            test.boxStack.get(i).display();
        }
    }
}

Related Problems 

[Coding Made Simple] Longest Increasing Subsequence

[Coding Made Simple] Maximum Sum Increasing Subsequence