85. Maximal Rectangle

Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing only 1's and return its area.

For example, given the following matrix:

1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0

Convert it to 84   Largest Rectangle in Histogram   

Build an array stores the height of the bar;

The example above should be:

1 0 1 0 0

2 0 2 1 1

3 1 3 2 2

4 0 0 3 0

And for each of the 1 0 1 0 0,    2 0 2 1 1,   3 1 3 2 2,  4 0 0 3 0 we could run a Largest Rectangle in Histogram, collect all the result and return the max.

Code:

public class Solution {
    public int maximalRectangle(char[][] matrix) {
        if(matrix.length == 0 || matrix[0].length == 0) return 0;
        int[][] hs = new int[matrix.length][matrix[0].length];
        for(int j = 0 ; j < matrix[0].length; j++){
            hs[0][j] = matrix[0][j] - '0';
        }
        for(int i = 1; i < matrix.length; i++){
            for(int j = 0 ; j < matrix[0].length; j++){
                if(matrix[i][j] == '1'){
                    hs[i][j] = 1 + hs[i - 1][j];
                } else {
                    hs[i][j] = 0;                
                }
            }
        }
        int ret = 0;
        for(int[] h : hs){
            ret = Math.max(ret,largestRectangleArea(h));
        }
        return ret;
        
    }
    
    public int largestRectangleArea(int[] h) {
        int ret = 0;
        Stack<Integer> s = new Stack<>();
        for(int i = 0 ; i < h.length; i++){
            if(s.empty() || h[s.peek()] <= h[i]){
                s.push(i);
            } else {
                while(!s.empty() && h[s.peek()] >= h[i]){
                    int index = s.pop();
                    
                    int left = s.empty() ? -1 : s.peek();
                    ret = Math.max(ret,h[index] * (i - 1 - left));
                }
                s.push(i);
            }
        }
        
        while(!s.empty()){
            int index = s.pop();
            int left = s.empty() ? -1 : s.peek();
            ret = Math.max(ret,h[index] * (h.length - 1 - left));
        }
        return ret;
    }
}

Another way to do this problem is calculated row by row;

maintain three arrays, left[], right[], height[]

left(i,j) = max(left(i-1,j), cur_left), cur_left can be determined from the current row

right(i,j) = min(right(i-1,j), cur_right), cur_right can be determined from the current row

height(i,j) = height(i-1,j) + 1, if matrix[i][j]=='1';

height(i,j) = 0, if matrix[i][j]=='0'

height counts the number of successive '1's above (plus the current one). The value of left & right means the boundaries of the rectangle which contains the current point with a height of value height

class Solution {public:
int maximalRectangle(vector<vector<char> > &matrix) {
    if(matrix.empty()) return 0;
    const int m = matrix.size();
    const int n = matrix[0].size();
    int left[n], right[n], height[n];
    fill_n(left,n,0); fill_n(right,n,n); fill_n(height,n,0);
    int maxA = 0;
    for(int i=0; i<m; i++) {
        int cur_left=0, cur_right=n; 
        for(int j=0; j<n; j++) { // compute height (can do this from either side)
            if(matrix[i][j]=='1') height[j]++; 
            else height[j]=0;
        }
        for(int j=0; j<n; j++) { // compute left (from left to right)
            if(matrix[i][j]=='1') left[j]=max(left[j],cur_left);
            else {left[j]=0; cur_left=j+1;}
        }
        // compute right (from right to left)
        for(int j=n-1; j>=0; j--) {
            if(matrix[i][j]=='1') right[j]=min(right[j],cur_right);
            else {right[j]=n; cur_right=j;}    
        }
        // compute the area of rectangle (can do this from either side)
        for(int j=0; j<n; j++)
            maxA = max(maxA,(right[j]-left[j])*height[j]);
    }
    return maxA;
}

Code from https://discuss.leetcode.com/topic/6650/share-my-dp-solution