Added 1 solution, updated 1 solution

Author: RodneyShag

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

@@ -11,12 +11,6 @@ public class Box {
  depth = d;
  }
 
- Box(Box other) {
- width = other.width;
- height = other.height;
- depth = other.depth;
- }
-
  public boolean canBeAbove(Box other) {
  return (other == null) || (width < other.width && height < other.height && depth < other.depth);
  }

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

@@ -2,58 +2,64 @@
 
 import java.util.*;
 
+// Based off Cracking the Coding Interview 6th Edition's Solution 1
+
 // Algorithm
 //
 // 1. Create Box class with `.canBeAbove(Box other)` function.
-// 2. Sort Boxes in descending height order. 
+// 2. Sort Boxes in descending height order. This ensures we don't have to look backwards in the list 
 // - 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
+// such as [width, height, depth] of [4,4,4] and [7,4,7], it doesn't matter which Box comes first
+// after sorting, since both Boxes 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. Experiment with each Box as a bottom and build the biggest stack possible.
+// 4. 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 with "Box i" at the bottom
 
 public class StackOfBoxes {
  public static int findMaxHeight(List<Box> boxes) {
  if (boxes == null || boxes.size() == 0) {
  return 0;
  }
  Collections.sort(boxes, (box1, box2) -> box2.height - box1.height); // sort in descending height order
- return findMaxHeight(boxes, 0, null, new HashMap<>(boxes.size()));
+ return findMaxHeight(boxes, -1, new HashMap<Integer, Integer>());
  }
- 
- 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);
+
+ private static int findMaxHeight(List<Box> boxes, int bottomIndex, Map<Integer, Integer> cache) {
+ if (cache.containsKey(bottomIndex)) {
+ return cache.get(bottomIndex);
  }
- 
- // 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);
+
+ int maxHeight = 0;
+ Box bottom = bottomIndex == -1 ? null : boxes.get(bottomIndex);
+
+ for (int i = bottomIndex + 1; i < boxes.size(); i++) {
+ if (boxes.get(i).canBeAbove(bottom)) {
+ int height = findMaxHeight(boxes, i, cache);
+ maxHeight = Math.max(maxHeight, height);
+ }
  }
- 
- // height without this Box
- int heightWithout = findMaxHeight(boxes, i + 1, bottom, cache);
- 
- int max = Math.max(heightWith, heightWithout);
- cache.put(i, max);
- return max;
+
+ maxHeight += bottomIndex == -1 ? 0 : bottom.height; 
+ cache.put(bottomIndex, maxHeight);
+ return maxHeight;
  }
 }
 
-// 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.
+// Time Complexity: O(n^2)
 // 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.
+
+// Alternate Solution: Cracking the Coding Interview 6th Edition Solution 2
+//
+// I didn't like this alternate solution since caching was done weirdly: Function had 2 changing
+// parameters (Box bottom, int offset) but cache only used 1 parameter.
+
+
+// Follow-up Question - What if rotation of boxes is allowed?
+//
+// 1. For each box, rotate it to all 6 possibilities: [w h d], [w d h], [h w d] [h d w], [d w h], [d h w].
+// 2. Notice it's impossible to stack 2 of these 6 boxes on top of each other, so if we insert all 6 boxes
+// into our list, we're still ensured only 1 of them can be selected for our solution.
+// 3. Create `List<Box> boxes` that is 6 times as large as the original list of boxes. Solve the problem for this list.

Chp. 17 - More Problems (Hard)/_17_08_Circus_Tower/CircusTower.java

@@ -0,0 +1,39 @@
+package _17_08_Circus_Tower;
+
+import java.util.*;
+
+public class CircusTower {
+ public static int findMax(int[][] persons) {
+ if (persons == null || persons.length == 0 || persons[0].length != 2) {
+ return 0;
+ }
+ Arrays.sort(persons, (a, b) -> {
+ if (a[0] != b[0]) {
+ return a[0] - b[0];
+ } else {
+ return b[1] - a[1];
+ }
+ });
+ 
+ int[] sortedArray = new int[persons.length];
+ int size = 0;
+ for (int[] person : persons) {
+ int num = person[1];
+ int start = 0;
+ int end = size; // 1 element past end of our sortedArray
+ while (start != end) {
+ int mid = (start + end) / 2;
+ if (sortedArray[mid] < num) {
+ start = mid + 1;
+ } else {
+ end = mid;
+ }
+ }
+ sortedArray[start] = num;
+ if (start == size) {
+ size++;
+ }
+ }
+ return size;
+ }
+}

Chp. 17 - More Problems (Hard)/_17_08_Circus_Tower/Tester.java

@@ -0,0 +1,9 @@
+package _17_08_Circus_Tower;
+
+public class Tester {
+ public static void main(String[] args) {
+ System.out.println("*** Test 8.13: Stack of Boxes\n");
+ int result = CircusTower.findMax(new int[][]{{2, 3}, {3, 3}, {4,3}, {5, 5}});
+ System.out.println(result);
+ }
+}