Maximal Rectangle

一. 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

Return 6.

Difficulty:Hard

TIME：42MIN

解法一（動態規劃）

雖然一開始也想到了動態規劃的解法，但是最優子結構設計上有一些問題，導致算法的時間複雜度爲O(n3) ，因此就沒有使用那個最優子結構。

這裏採用的最優子結構使用三個數組，分別是height，left和right數組，記錄每一行某個點所在的最大的長方形的高度，左邊界和右邊界。這個最優子結構難以理解的地方就是怎樣才能保證該點記錄的一定是最大的長方形的高度，左邊界和右邊界。

對於某個矩陣來說，比如：

/*
0 0 1 0 0
0 1 1 1 0
1 1 1 1 1

第一行
  0 0 1 0 0
h 0 0 1 0 0
l 0 0 2 0 0
r 5 5 3 5 5

第二行
  0 1 1 1 0
h 0 1 2 1 0
l 0 1 2 1 0
r 5 4 3 4 5

第三行 略
*/

可以發現，每個點記錄的確實是該點所在可能的最大的矩陣的高度，左邊界和右邊界。注意這裏記錄的是可能，比如對於第二行來說，記錄的第二個1的矩陣面積爲2，顯然不是最大的，不過，這一點也至關重要，就是矩陣的記錄一定是高度優先的，也就是我只記錄以該點所在的最大高度的矩陣，而我並不關心這個矩陣是否是最大的矩陣。

因爲次高的矩陣一定會有其他點來記錄，比如第二行的第一個1和第三個1記錄的就是次高的矩陣。因此，就算每個點都記錄該點的最高的矩陣，但是我們還是會記錄出所有的可能的最大的矩陣，而不會漏掉任何一種情況。

這個就是這種解法最精妙的地方。

int maximalRectangle(vector<vector<char>>& matrix) {
    if(matrix.empty() || matrix[0].empty())
        return 0;
    int result = 0;
    vector<int> height(matrix[0].size(), 0);
    vector<int> left(matrix[0].size(), 0);
    vector<int> right(matrix[0].size(), matrix[0].size());
    for(int i = 0; i < matrix.size(); i++) {
        int curLeft = 0, curRight = matrix[0].size();
        for(int j = 0; j < matrix[0].size(); j++) {
            if(matrix[i][j] == '1') {
                height[j]++;
                left[j] = max(left[j], curLeft); //記錄最高的矩陣的左邊界
            }
            else {
                height[j] = 0;
                left[j] = 0;
                curLeft = j + 1;
            }
        }
        for(int j = matrix[0].size() - 1; j >= 0; j--) {
            if(matrix[i][j] == '1')
                right[j] = min(right[j], curRight); //記錄最高的矩陣的右邊界
            else {
                right[j] = matrix[0].size();
                curRight = j;
            }
            result = max(result,(right[j]-left[j]) * height[j]);
        }
    }
    return result;
}

代碼的時間複雜度爲O(n2) 。

解法二（棧）

之前做過一道題Largest Rectangle in Histogram，一開始確實沒有聯想到這兩道題的相關性，不過，直方圖既然可以在O(n) 的時間內求解，那麼把這個矩陣看出n維的直方圖，那麼就可以在O(n2) 內求解。

int maximalRectangle(vector<vector<char>>& matrix) {
    if(matrix.empty() || matrix[0].empty())
        return 0;
    int result = 0;
    vector<int> v(matrix[0].size() + 1, 0);
    for(int i = 0; i < matrix.size(); i++) {
        vector<int> s;
        for(int j = 0; j <= matrix[0].size(); j++) {
            if(j < matrix[0].size() && matrix[i][j] == '1')
                v[j]++;
            else
                v[j] = 0;
            while(!s.empty() && v[j] < v[s.back()]) {
                int h = v[s.back()];
                s.pop_back();
                int k = s.empty() ? -1 : s.back();
                result = max((j - k - 1) * h, result);
            }
            s.push_back(j);
        }
    }
    return result;
}

代碼的時間複雜度爲O(n2) 。