Updated 1 solution

Author: RodneyShag

Chp. 08 - Recursion and Dynamic Programming/_8_13_Stack_of_Boxes/Box.java

@@ -1,47 +1,25 @@
 package _8_13_Stack_of_Boxes;
 
-/* Used in 9.10 */
 public class Box {
  int width;
  int height;
  int depth;
 
- /* Constructor */
  Box(int w, int h, int d) {
  width = w;
  height = h;
  depth = d;
  }
 
- /* Constructor */
  Box(Box other) {
  width = other.width;
  height = other.height;
  depth = other.depth;
  }
 
- /* A box can be placed on 1) an empty platform (that's what the "other == null" is for), or 2) a bigger box (in every dimension) */
- public boolean canPlaceAbove(Box other) {
+ public boolean canBeAbove(Box other) {
  return (other == null) || (width < other.width && height < other.height && depth < other.depth);
  }
-
- /* Book didn't have these 2 functions. I think they're needed so Boxes can be hashed correctly */
-
- @Override
- public boolean equals(Object other) {
- if (other == this) {
- return true;
- } else if (other == null || !(other instanceof Box)) {
- return false;
- }
- Box otherBox = (Box) other;
- return width == otherBox.width && height == otherBox.height && depth == otherBox.depth;
- }
-
- @Override
- public int hashCode() {
- return 2 * width + 3 * height + 5 * depth;
- }
 
  @Override
  public String toString() {

Chp. 08 - Recursion and Dynamic Programming/_8_13_Stack_of_Boxes/StackOfBoxes.java

@@ -1,70 +1,59 @@
 package _8_13_Stack_of_Boxes;
 
-import java.util.ArrayDeque;
-import java.util.HashMap;
-
-// Famous box stacking problem 
-// 
-// (Solution based off book's 2nd solution)
-// 
-// Tips:
-// - Have "Box" class with ".canBeAbove(Box other)" function.
-// - Use HashMap<Box, ArrayDeque<Box>> to cache found solutions. Need to override .equals() and hashCode().
-// - Having "Box bottom" as a parameter is crucial but hard to think of.
-// - Deep copy (which is what I did) or cloning (which is what book did) is needed to avoid insidious bugs.
+import java.util.*;
+
+// Algorithm
+//
+// 1. Create Box class with `.canBeAbove(Box other)` function.
+// 2. Sort Boxes in descending height order. 
+// - This problem uses `<` instead of `<=` for Box heights. If we have 2 Boxes of equal height,
+// and [width, height, depth] of [4,4,4] and [7,4,7], it doesn't matter which Box comes first
+// after sorting, since both `Box`es can't be in the final solution. Box 1 cannot be on top of Box 2,
+// and Box 2 cannot be on top of Box 1. 
+// 3. For each Box, you have 2 choices:
+// 1. Use the Box
+// 2. Don't use the Box.
+// 4. Recursively try both options. Return the larger height returned from these 2 options.
+// 5. Use a Map<Integer, Integer> cache to save solutions to sub-problems
+// 1. "key" is the index `i` in the list of boxes
+// 2. "value" is the max height possible from that Box to the end of our list of Boxes
 
 public class StackOfBoxes {
- public static ArrayDeque<Box> buildTallestStack(ArrayDeque<Box> boxes) {
- return buildTallestStack(boxes, null, new HashMap<Box, ArrayDeque<Box>>());
- }
-
- public static ArrayDeque<Box> buildTallestStack(ArrayDeque<Box> boxes, Box bottom, HashMap<Box, ArrayDeque<Box>> cache) {
- if (cache.containsKey(bottom)) { // checks to see if we already computed the solution
- /* CRUCIAL to do a deep copy. The result we return is going to be altered, and we don't want the key of an entry
- already placed in the HashMap to be altered. Without deep copy, we get incorrect solutions when testing */
- return deepCopy(cache.get(bottom)); 
- }
-
- int currHeight = 0;
- int bestHeight = 0;
- ArrayDeque<Box> currStack = new ArrayDeque<>();
- ArrayDeque<Box> bestStack = new ArrayDeque<>();
-
- for (Box box : boxes) {
- if (box.canPlaceAbove(bottom)) {
- currStack = buildTallestStack(boxes, box, cache);
- currHeight = stackHeight(currStack);
- if (currHeight > bestHeight) {
- bestHeight = currHeight;
- bestStack = currStack;
- }
- }
- }
-
- if (bottom != null) {
- bestStack.addFirst(bottom);
- cache.put(bottom, bestStack);
+ public static int findMaxHeight(List<Box> boxes) {
+ if (boxes == null || boxes.size() == 0) {
+ return 0;
  }
-
- return bestStack;
+ Collections.sort(boxes, (box1, box2) -> box2.height - box1.height); // sort in descending height order
+ return findMaxHeight(boxes, 0, null, new HashMap<>(boxes.size()));
  }
-
- private static int stackHeight(ArrayDeque<Box> boxes) {
- if (boxes == null) {
+ 
+ private static int findMaxHeight(List<Box> boxes, int i, Box bottom, Map<Integer, Integer> cache) { 
+ if (i >= boxes.size()) {
  return 0;
+ } else if (cache.containsKey(i)) {
+ return cache.get(i);
  }
- int height = 0;
- for (Box box : boxes) {
- height += box.height;
- }
- return height;
- }
-
- private static ArrayDeque<Box> deepCopy(ArrayDeque<Box> boxes) {
- ArrayDeque<Box> result = new ArrayDeque<>();
- for (Box box : boxes) {
- result.add(new Box(box));
+ 
+ // height with this Box
+ Box newBottom = boxes.get(i);
+ int heightWith = 0;
+ if (newBottom.canBeAbove(bottom)) {
+ heightWith = newBottom.height + findMaxHeight(boxes, i + 1, newBottom, cache);
  }
- return result;
+ 
+ // height without this Box
+ int heightWithout = findMaxHeight(boxes, i + 1, bottom, cache);
+ 
+ int max = Math.max(heightWith, heightWithout);
+ cache.put(i, max);
+ return max;
  }
 }
+
+// Time Complexity: Without caching, the recursive part is O(2^n) since there are `n` boxes,
+// and 2 options for each box (use or don't use). With caching, the recursive part is just O(n).
+// The total time complexity is therefore O(n log n) due to sorting.
+// Space Complexity: O(n) due to recursion.
+
+// - A Dynamic Programming Iterative solution (using an array instead of a HashMap)
+// is also possible. It will have the same Time/Space complexity as the above solution.

Chp. 08 - Recursion and Dynamic Programming/_8_13_Stack_of_Boxes/Tester.java

@@ -1,20 +1,20 @@
 package _8_13_Stack_of_Boxes;
 
-import java.util.ArrayDeque;
+import java.util.*;
 
 public class Tester {
  public static void main(String[] args) {
  System.out.println("*** Test 8.13: Stack of Boxes\n");
- ArrayDeque<Box> boxes = new ArrayDeque<>();
+ List<Box> boxes = new LinkedList<>();
  boxes.add(new Box(3, 4, 1));
  boxes.add(new Box(8, 6, 2));
  boxes.add(new Box(4, 8, 3));
  test(boxes);
  }
 
- private static void test(ArrayDeque<Box> boxes) {
+ private static void test(List<Box> boxes) {
  System.out.println("Original boxes: " + boxes + "\n");
- ArrayDeque<Box> stack = StackOfBoxes.buildTallestStack(boxes);
- System.out.println("Tallest stack:  " + stack);
+ int height = StackOfBoxes.findMaxHeight(boxes);
+ System.out.println("Height of tallest stack: " + height);
  }
 }