[Coding Made Simple] Maximum Size Rectangle of All 1's

Given a 2D matrix of 0s and 1s, find maximum size rectangle of all 1s in this matrix.

Brute force solution is very inefficient. 

A better solution is to convert this problem to multiple different Largest Rectangle in Histogram calculations and 

uses dynamic programming to avoid constructing each new histogram from scratch.

Algorithm: O(m * n) runtime, O(min(m, n)) space

1. construct a 1D histogram array of length min(m, n), with all heights initialized to 0.

2.  for each new row/col, construct a new histogram by the following rule.

　　a. if a cell is 0, then its corresponding histogram height is 0.

　　b. if a cell is 1, add 1 to the previous corrsponding histogram height. 

3.  calculate the max rectangle area in each new histogram and return the max of all these max rectangle areas.

import java.util.Stack;

public class MaxRectangle {
    public static int getMaxRecArea(int[][] matrix) {
        if(matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return 0;
        }
        int max = 0;
        int histogramLen = Math.min(matrix.length, matrix[0].length);
        int histogramIter = Math.max(matrix.length, matrix[0].length);
        int[] heights = new int[histogramLen];
        for(int i = 0; i < histogramIter; i++){
            for(int j = 0; j < histogramLen; j++) {
                int currCell = histogramLen == matrix[0].length ? matrix[i][j] : matrix[j][i];
                if(currCell != 0) {
                    heights[j] += currCell;
                }
                else {
                    heights[j] = 0;
                }
            }
            max = Math.max(max, largestRectangleArea(heights));
        }
        return max;
    }
    public static int largestRectangleArea(int[] height) {
        if(height == null || height.length == 0){
            return 0;
        }
        Stack<Integer> idxStack = new Stack<Integer>();
        int currIdx = 0; int area = 0; int maxArea = 0;
        while(currIdx < height.length){
            if(idxStack.isEmpty() || height[currIdx] >= height[idxStack.peek()]){
                idxStack.push(currIdx);
                currIdx++;
            }
            else{
                int top = idxStack.pop();
                int leftBoundIdx = idxStack.isEmpty() == true ? -1 : idxStack.peek();
                int rightBoundIdx = currIdx - 1;
                area = height[top] * (rightBoundIdx - leftBoundIdx);
                maxArea = Math.max(maxArea, area);
            }
        }
        while(!idxStack.isEmpty()){
            int top = idxStack.pop();
            int leftBoundIdx = idxStack.isEmpty() == true ? -1 : idxStack.peek();
            int rightBoundIdx = currIdx - 1;
            area = height[top] * (rightBoundIdx - leftBoundIdx);
            maxArea = Math.max(maxArea, area);
        }
        return maxArea;
    } 
    public static void main(String[] args) {
        int[][] matrix1 = {{1,1,0,0,1}, {0,1,0,0,1},{0,0,1,1,1},{0,0,1,1,1},{0,0,0,0,1}};
        int[][] matrix2 = {{1,0,0,1,1,1},{1,0,1,1,0,1},{0,1,1,1,1,1},{0,0,1,1,1,1}};
        System.out.println(getMaxRecArea(matrix1));
        System.out.println(getMaxRecArea(matrix2));        
    }
}

Related Problems

[LintCode] Largest Rectangle in Histogram