LeetCode

Maximal Rectangle

2014.2.26 20:27

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

Solution:

　　The worst solution for this problem should be O(n^4), and you will use O(n^2) space to speed it up to O(n^3).

　　But we're discussing here an O(n^2) solution. Should you remember the problem Largest Rectangle in Histogram, you might find out its connection with this one. See the matrix below, we'll calculate the cumulated sum top-down:

　　　　[1, 0, 0, 1] => [1, 0, 0, 1]

　　　　[1, 1, 1, 0] => [2, 1, 1, 0]

　　　　[0, 0, 1, 1] => [0, 0, 2, 1]

　　　　[0, 1, 1, 1] => [0, 1, 3, 2]

　　If matrx[i][j] is zero, sum[i][j] = 0, otherwise sum[i][j] += matrix[i][j].

　　With this sum matrix, every row can be thought of as a histogram. You may use the code from that problem to calculate the maximal rectangle in the histogram. Do this for every row and you'll get the final result.

　　Time complexity is O(n^2), space complexity is O(n). You don't need to store the sum matrix. Instead, just updating the sum row for n times will be enough.

Accepted code:

// 1AC, great job!
class Solution {
public:
    int maximalRectangle(vector<vector<char> > &matrix) {
        int n, m;
        
        n = (int)matrix.size();
        if (n == 0) {
            return 0;
        }
        m = (int)matrix[0].size();
        if (m == 0) {
            return 0;
        }
        
        vector<int> histogram;
        
        histogram.resize(m);
        int i, j;
        
        for (j = 0; j < m; ++j) {
            histogram[j] = 0;
        }
        
        int max_area = 0;
        for (i = 0; i < n; ++i) {
            for (j = 0; j < m; ++j) {
                if (matrix[i][j] == '0') {
                    histogram[j] = 0;
                } else {
                    histogram[j] = histogram[j] + 1;
                }
            }
            max_area = max(max_area, largestRectangleArea(histogram));
        }
        
        histogram.clear();
        return max_area;
    }
private:
    int largestRectangleArea(vector<int> &height) {
        int i;
        int n;
        
        n = (int)height.size();
        if (n == 0) {
            return 0;
        }
        
        int max_area = 0;
        int area;
        stack<int> st;
        int top;
        
        for (i = 0; i < n; ++i) {
            if (st.empty() || height[st.top()] <= height[i]) {
                st.push(i);
            } else {
                while (!st.empty() && height[st.top()] > height[i]) {
                    top = st.top();
                    st.pop();
                    if (st.empty()) {
                        area = i * height[top];
                    } else {
                        area = (i - st.top() - 1) * height[top];
                    }
                    if (area > max_area) {
                        max_area = area;
                    }
                }
                st.push(i);
            }
        }
        while (!st.empty()) {
            top = st.top();
            st.pop();
            if (st.empty()) {
                area = i * height[top];
            } else {
                area = (i - st.top() - 1) * height[top];
            }
            if (area > max_area) {
                max_area = area;
            }
        }
        
        return max_area;
    }
};