Max rectangle of 1s: done

Author: rampatra

src/main/java/com/rampatra/dynamicprogramming/FibonacciNumbers.java

@@ -13,7 +13,7 @@
 public class FibonacciNumbers {
 
     /**
-     * Computes first {@param k} fibonacci numbers using
+     * Computes first {@code k} fibonacci numbers using
      * bottom-up DP approach.
      * <p/>
      * Time complexity: O(k)

src/main/java/com/rampatra/dynamicprogramming/LongestIncreasingSubSequence.java

@@ -1,11 +1,8 @@
 package com.rampatra.dynamicprogramming;
 
 /**
- * Created by IntelliJ IDEA.
- *
  * @author rampatra
  * @since 9/29/15
- * @time: 10:15 PM
  */
 public class LongestIncreasingSubSequence {
 
@@ -26,11 +23,11 @@ public class LongestIncreasingSubSequence {
      * To get LIS of a given array, we need to return max(L(i)) where 0 < i < n So the LIS problem has optimal
      * substructure property as the main problem can be solved using solutions to sub-problems.
      *
-     * @param a
+     * @param arr
      * @return
      */
-    public static int getLongestIncreasingSubSequenceLength(int[] a) {
-        int len = a.length, maxLisLength = 0;
+    public static int getLongestIncreasingSubSequenceLength(int[] arr) {
+        int len = arr.length, maxLisLength = 0;
         int[] lis = new int[len];
 
         for (int i = 0; i < len; i++) {
@@ -39,7 +36,7 @@ public static int getLongestIncreasingSubSequenceLength(int[] a) {
 
         for (int i = 1; i < len; i++) {
             for (int j = 0; j < i; j++) {
-                if (a[i] > a[j] && lis[i] < lis[j] + 1)
+                if (arr[i] > arr[j] && lis[i] < lis[j] + 1)
                     lis[i] = lis[j] + 1;
             }
         }

src/main/java/com/rampatra/dynamicprogramming/MaximumRectangleOf1sInMatrix.java

@@ -0,0 +1,79 @@
+package com.rampatra.dynamicprogramming;
+
+import com.rampatra.stacks.MaxRectangleAreaInHistogram;
+
+/**
+ * Given a 2D matrix of 0s and 1s. Find the largest rectangle of all 1s in this matrix.
+ * <p>
+ * Level: Hard
+ * Time Complexity: O(rows * cols)
+ * Space Complexity: O(cols)
+ * <p>
+ * Note: If the number of cols is too large as compared to rows then you can process the matrix column-wise and create
+ * the histogram for each column. In this way the hist[] array will be of size = number of rows in the matrix.
+ *
+ * @author rampatra
+ * @since 2019-04-05
+ */
+public class MaximumRectangleOf1sInMatrix {
+
+    private static int getMaxRectangleSizeOf1s(int[][] binaryMatrix) {
+        int area;
+        int maxArea = 0;
+        int[] hist = new int[binaryMatrix[0].length];
+
+        /*
+            Create a histogram with the rows. Start with the first row, create a histogram and then extend this 
+            histogram based on the elements in the next rows. If the element in the row is a 0 then make the bar in 
+            the histogram 0 or else just increase the bar in the histogram. 
+            
+            Basically, we are creating a histogram with all the 1s in the matrix and then finding the maximum 
+            rectangle size of this histogram. 
+          */
+        for (int row = 0; row < binaryMatrix.length; row++) {
+            for (int col = 0; col < binaryMatrix[0].length; col++) {
+                if (binaryMatrix[row][col] == 0) {
+                    hist[col] = 0;
+                } else {
+                    hist[col] += binaryMatrix[row][col];
+                }
+            }
+            area = MaxRectangleAreaInHistogram.getMaxRectangleArea(hist);
+            maxArea = Math.max(maxArea, area);
+        }
+        return maxArea;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(getMaxRectangleSizeOf1s(
+                new int[][]{{0, 1, 1},
+                        {0, 0, 1},
+                        {0, 1, 1}}));
+        
+        System.out.println(getMaxRectangleSizeOf1s(
+                new int[][]{{0, 1, 1, 1, 0},
+                        {0, 0, 1, 1, 0},
+                        {0, 1, 1, 1, 0}}));
+
+        System.out.println(getMaxRectangleSizeOf1s(
+                new int[][]{{1, 1, 1, 0},
+                        {1, 1, 1, 1},
+                        {0, 1, 1, 0},
+                        {0, 1, 1, 1},
+                        {1, 0, 0, 1},
+                        {1, 1, 1, 1}}));
+
+        // edge cases
+        System.out.println(getMaxRectangleSizeOf1s(
+                new int[][]{{}}));
+
+        System.out.println(getMaxRectangleSizeOf1s(
+                new int[][]{{0}}));
+
+        System.out.println(getMaxRectangleSizeOf1s(
+                new int[][]{{0, 0, 0}}));
+
+        System.out.println(getMaxRectangleSizeOf1s(
+                new int[][]{{1}}));
+    }
+}

src/main/java/com/rampatra/stacks/MaxRectangleAreaInHistogram.java

@@ -0,0 +1,79 @@
+package com.rampatra.stacks;
+
+/**
+ * Given a bar histogram, calculate the maximum possible rectangle area in the histogram. Consider each bar is 1 unit
+ * wide.
+ * <p>
+ * Level: Hard
+ * Time Complexity: O(n)
+ * Space Complexity: O(n)
+ *
+ * @author rampatra
+ * @since 2019-04-04
+ */
+public class MaxRectangleAreaInHistogram {
+
+    public static int getMaxRectangleArea(int[] hist) {
+        Stack<Integer> stack = new Stack<>();
+        int area;
+        int maxArea = 0;
+        int currMaxIndex;
+        int i = 0;
+
+        while (i < hist.length) {
+            // keep adding indexes of bars which are equal to or larger than what's there in stack currently
+            if (stack.isEmpty() || hist[i] >= hist[stack.peek()]) {
+                stack.push(i);
+                i++;
+            } else {
+                /* 
+                    Whenever we encounter a bar smaller than what is there in the stack, we pop the topmost 
+                    element and compute the area.
+                 */
+                currMaxIndex = stack.pop();
+                /*
+                    Compute area from stack.peek() to (i - 1), 
+                        
+                        Why (i - 1)?      Because i has been incremented and is now pointing to the next bar in the
+                                          histogram
+                        
+                        Why stack.peak()? Because hist[stack.peek() + 1] is the last bar in the histogram with height more 
+                                          than or equal to the current bar height
+                 */
+                area = hist[currMaxIndex] * (i - (stack.isEmpty() ? 0 : stack.peek() + 1));
+                maxArea = Math.max(maxArea, area);
+            }
+        }
+
+        /*
+            Process the left over elements in the stack. Note: the below code can also be merged with the loop
+            above but I have separated it out for simplicity.
+         */
+        while (!stack.isEmpty()) {
+            currMaxIndex = stack.pop();
+            area = hist[currMaxIndex] * (i - (stack.isEmpty() ? 0 : stack.peek() + 1));
+            maxArea = Math.max(maxArea, area);
+        }
+
+        return maxArea;
+    }
+
+    public static void main(String[] args) {
+        /*
+                  ___
+            ___   |  |  ___
+            |  |__|  |__|  |
+            |  |  |  |  |  |
+             2  1  3  1  2
+             
+             Max. area in this histogram is 5, which is the bottom horizontal rectangle.
+         */
+        System.out.println(getMaxRectangleArea(new int[]{2, 1, 3, 1, 2})); // maxArea = 5
+        System.out.println(getMaxRectangleArea(new int[]{2, 1, 5, 6, 2, 3})); // maxArea = 10
+        System.out.println(getMaxRectangleArea(new int[]{2, 2, 2, 6, 1, 5, 4, 2, 2, 2, 2})); // maxArea = 12
+        
+        // edge cases
+        System.out.println(getMaxRectangleArea(new int[]{})); // maxArea = 0
+        System.out.println(getMaxRectangleArea(new int[]{1})); // maxArea = 1
+    }
+}