Updated 4 solutions

Author: RodneyShag

Chp. 01 - Arrays and Strings/_1_7_Rotate_Matrix/RotateMatrix.java

@@ -1,25 +1,41 @@
 package _1_7_Rotate_Matrix;
 
 public class RotateMatrix {
-    /* Rotates square image[][] 90 degrees clockwise */
+    private static int n;
+
     public static void rotate90clockwise(int[][] image) {
-        int n = image.length;
-        for (int layer = 0; layer < n/2; layer++) {
-            int first = layer;
-            int last = n - 1 - layer;
-            for (int i = first; i < last; i++) {
-                int offset = i - first;
-                /* 4-way swap */
-                int temp                     = image[first][first + offset];
-                image[first][first + offset] = image[last - offset][first];
-                image[last - offset][first]  = image[last][last - offset];
-                image[last][last - offset]   = image[first + offset][last];
-                image[first + offset][last]  = temp;
+        if (image == null || image.length != image[0].length) {
+            return;
+        }
+        n = image.length;
+        transpose(image);
+        flipHorizontally(image);
+    }
+    
+    private static void transpose(int[][] image) {
+        for (int row = 0; row < n; row++) {
+            for (int col = row + 1; col < n; col++) {
+                swap(image, row, col, col, row);
+            }
+        }
+    }
+    
+    private static void flipHorizontally(int[][] image) {
+        for (int row = 0; row < n; row++) {
+            for (int col = 0; col < n / 2; col++) {
+                swap(image, row, col, row, n - 1 - col);
             }
         }
     }
 
-    /* For fun: I tried rotating image by 180 degrees */
+    // Swaps 2 elements in a 2-D array
+    private static void swap(int[][] image, int r1, int c1, int r2, int c2) {
+        int temp      = image[r1][c1];
+        image[r1][c1] = image[r2][c2];
+        image[r2][c2] = temp;
+    }
+
+    // For fun: I tried rotating image by 180 degrees
     public static int[][] rotate180(int[][] image) {
         int n = image.length;
         for (int row = 0; row < n/2; row++) {
@@ -36,15 +52,8 @@ public static int[][] rotate180(int[][] image) {
         }
         return image;
     }
-
-    /* Swaps 2 elements in a 2-D array */
-    private static void swap(int[][] image, int r1, int c1, int r2, int c2) {
-        int temp      = image[r1][c1];
-        image[r1][c1] = image[r2][c2];
-        image[r2][c2] = temp;
-    }
 }
 
 //  Time Complexity: O(n^2). Impossible to do better since must touch all n^2 elements.
 // Space Complexity: O(1)
-// Time/Space complexities are the same for both the 90-degree rotation and 180-degree rotation.
+// Time/Space complexities are the same for both the 90-degree rotation and 180-degree rotation.

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

@@ -3,12 +3,16 @@
 public class Tester {
     public static void main(String[] args) {
         System.out.println("*** Test 8.1: Triple Step\n");
-        test(3);
-        test(5);
+        test(0); System.out.println();
+        test(1); System.out.println();
+        test(2); System.out.println();
+        test(3); System.out.println();
+        test(5); System.out.println();
     }
 
-	private static void test(int steps) {
-        System.out.format("(Iterative Solution) %d Step Staircase: %2d ways \n", steps, TripleStep.numPathsIterative(steps));
+    private static void test(int steps) {
         System.out.format("(Recursive Solution) %d Step Staircase: %2d ways \n", steps, TripleStep.numPathsRecursive(steps));
+        System.out.format("(Iterative Solution) %d Step Staircase: %2d ways \n", steps, TripleStep.numPathsIterative(steps));
+        System.out.format("(Iterative Solution) %d Step Staircase: %2d ways \n", steps, TripleStep.numPathsIterativeNoArray(steps));
     }
 }

Chp. 08 - Recursion and Dynamic Programming/_8_01_Triple_Step/TripleStep.java

@@ -4,49 +4,65 @@
 // --------------------------------------------------------
 // 1) Recursive               O(n)      O(n)
 // 2) Iterative using array   O(n)      O(n)             
-// 3) Iterative, no array     O(n)      O(1)     Favorite     
+// 3) Iterative, no array     O(n)      O(1)      Favorite     
 
 public class TripleStep {
-    private final static int staircaseSize = 100;
-    private static int[] cache = new int[staircaseSize];
 
-    /* Recursive Solution */
-    public static int numPathsRecursive(int steps) {
-        if (steps > staircaseSize) {
-            return -1;
-        }
-        cache[0] = 1; // setting the value to 1 and not to 0 is crucial
-        return numPathsRecursive_helper(steps);
+    // Recursive Solution
+    public static int numPathsRecursive(int n) {
+        int[] cache = new int[n + 1];
+        return numPathsRecursive(n, cache);
     }
 
-    private static int numPathsRecursive_helper(int steps) {
-        if (steps < 0) {
+    private static int numPathsRecursive(int n, int[] cache) {
+        if (n < 0) { // this can happen due to our recursive calls
             return 0;
+        } else if (n == 0 || n == 1) {
+            return 1;
         }
-        if (cache[steps] > 0) {
-            return cache[steps];
+        if (cache[n] > 0) {
+            return cache[n];
         }
-        cache[steps] = numPathsRecursive_helper(steps - 1)
-                     + numPathsRecursive_helper(steps - 2)
-                     + numPathsRecursive_helper(steps - 3);
+        cache[n] = numPathsRecursive(n - 1, cache)
+                 + numPathsRecursive(n - 2, cache)
+                 + numPathsRecursive(n - 3, cache);
 
-        return cache[steps];
+        return cache[n];
     }
 
-    /* Iterative Solution */
-    public static int numPathsIterative(int staircaseSize) {
-        int[] cache = new int[staircaseSize + 1];
+    // Iterative Solution
+    public static int numPathsIterative(int n) {
+        if (n == 0 || n == 1) {
+            return 1;
+        } else if (n == 2) {
+            return 2;
+        }
+        int[] cache = new int[n + 1];
         cache[0] = 1;
         cache[1] = 1;
         cache[2] = 2;
-        for (int i = 3; i <= staircaseSize; i++) {
+        for (int i = 3; i <= n; i++) {
             cache[i] = cache[i - 3] + cache[i - 2] + cache[i - 1];
         }
-        return cache[staircaseSize];
+        return cache[n];
     }
 
-    /*
-     * Solution 3: Can be done in O(1) space by saving just the last 3 elements of
-     * array, like in Fibonacci solution
-     */
+    public static int numPathsIterativeNoArray(int n) {
+        if (n == 0 || n == 1) {
+            return 1;
+        } else if (n == 2) {
+            return 2;
+        }
+        int prev2 = 1;
+        int prev = 1;
+        int curr = 2;
+        int next = 0;
+        for (int i = 3; i <= n; i++) {
+            next = prev2 + prev + curr;
+            prev2 = prev;
+            prev = curr;
+            curr = next;
+        }
+        return curr;
+    }
 }

Chp. 08 - Recursion and Dynamic Programming/__Intro_Fibonacci/Fibonacci.java

@@ -12,35 +12,55 @@
 
 public class Fibonacci {
 
-    /* Solution 1 */
-    private final static int cacheSize = 100;
-    public static int[] cache = new int[cacheSize];
-
+    // Solution 1
     public static int fibRecursive(int n) {
-        if (n < 0) {
-            return -1;
-        }
-        cache[0] = 1; // We are defining 0th Fibonacci number as 1
-        cache[1] = 1;
-        return fibRecursiveHelper(n);
+        int[] cache = new int[n + 1];
+        return fibRecursive(n, cache);
     }
 
-    public static int fibRecursiveHelper(int n) {
+    private static int fibRecursive(int n, int[] cache) {
+        if (n <= 0) {
+            return 0;
+        } else if (n == 1) {
+            return 1;
+        }
         if (cache[n] > 0) {
             return cache[n];
         }
-        cache[n] = fibRecursiveHelper(n - 1) + fibRecursiveHelper(n - 2);
+        cache[n] = fibRecursive(n - 1, cache)
+                 + fibRecursive(n - 2, cache);
+
         return cache[n];
     }
 
-    /* Solution 2 - omitted (but very similar to Solution 3) */
+    // Solution 2
+    public static int fibIterative(int n) {
+        if (n <= 0) {
+            return 0;
+        } else if (n == 1) {
+            return 1;
+        }
+        int[] cache = new int[n + 1];
+        cache[0] = 0;
+        cache[1] = 1;
+        for (int i = 2; i <= n; i++) {
+            cache[i] = cache[i - 2] + cache[i - 1];
+        }
+        return cache[n];
+    }
 
-    /* Solution 3 */
-    public static int fibIterative(int n) { // assumes 1st and 2nd Fibonacci numbers are defined as value 1.
+    // Solution 3
+    public static int fibIterativeNoArray(int n) {
+        if (n == 0) {
+            return 0;
+        } else if (n == 1) {
+            return 1;
+        }
         int prev = 0;
         int curr = 1;
+        int next = 0;
         for (int i = 2; i <= n; i++) {
-            int next = prev + curr;
+            next = prev + curr;
             prev = curr;
             curr = next;
         }

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

@@ -6,9 +6,15 @@ public static void main(String[] args) {
         for (int i = 0; i < 16; i++) {
             System.out.print(Fibonacci.fibRecursive(i) + " ");
         }
+        
         System.out.println();
-        for (int i = 1; i < 16; i++) {
+        for (int i = 0; i < 16; i++) {
             System.out.print(Fibonacci.fibIterative(i) + " ");
         }
+        
+        System.out.println();
+        for (int i = 0; i < 16; i++) {
+            System.out.print(Fibonacci.fibIterativeNoArray(i) + " ");
+        }
     }
 }

Chp. 17 - More Problems (Hard)/_17_21_Volume_of_Histogram/VolumeOfHistogram.java

@@ -1,28 +1,37 @@
 package _17_21_Volume_of_Histogram;
 
-// Main idea: For each index, the tallest wall anywhere to the left, and to the right, determine
-//            the amount of water the index will hold. We can calculate this iteratively.
+// Main idea: For each index, 2 walls (the tallest wall anywhere to the left, and to the right), together
+//            determine the amount of water the index will hold. We can calculate this iteratively.
 
 public class VolumeOfHistogram {
-    public static int computeHistogramVolume(int[] histo) {
-        /* Calculate left maxes */
-        int[] leftMax = new int[histo.length];
-        leftMax[0] = histo[0];
-        for (int i = 1; i < histo.length; i++) {
-            leftMax[i] = Math.max(leftMax[i-1], histo[i]);
+    public static int computeHistogramVolume(int[] height) {
+        if (height == null || height.length <= 1) {
+            return 0;
         }
+        int size = height.length;
 
-        /* Calculate right maxes, along with "min" and "sum" */
-        int sum = 0;
-        int rightMax = 0;
-        for (int i = histo.length - 1; i >= 0; i--) {
-            rightMax = Math.max(rightMax, histo[i]);
-            sum += Math.min(leftMax[i], rightMax) - histo[i];
+        // Calculate left maxes
+        int[] leftMax = new int[size];
+        leftMax[0] = height[0];
+        for (int i = 1; i < size; i++) {
+            leftMax[i] = Math.max(leftMax[i - 1], height[i]);
         }
-        return sum;
+
+        // Calculate right maxes
+        int[] rightMax = new int[size];
+        rightMax[size - 1] = height[size - 1];
+        for (int i = size - 2; i >= 0; i--) {
+            rightMax[i] = Math.max(rightMax[i + 1], height[i]);
+        }
+        
+        // Calculate amount of water that can be stored above each spot on histogram
+        int water = 0;
+        for (int i = 1; i < size - 1; i++) {
+            water += Math.min(leftMax[i], rightMax[i]) - height[i];
+        }
+        return water;
     }
 }
 
-
 //  Time Complexity: O(n)
 // Space Complexity: O(n)