【LeetCode】85. 最大矩形 （单调栈经典应用）

给定一个仅包含 0 和 1 的二维二进制矩阵，找出只包含 1 的最大矩形，并返回其面积。
示例:
输入:
[
[“1”,“0”,“1”,“0”,“0”],
[“1”,“0”,“1”,“1”,“1”],
[“1”,“1”,“1”,“1”,“1”],
[“1”,“0”,“0”,“1”,“0”]
]
输出: 6
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximal-rectangle
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

思路

根据这个图，我们很容易可以算出，每个1的上面有几个连续的1，例如样例：

  ["1","0","1","0","0"],
  ["1","0","1","1","1"],
  ["1","1","1","1","1"],
  ["1","0","0","1","0"]

我们可以求出一个h[][]，用于表示，每个1的作为底，他的高度为多少，此处只需要遍历一遍数组即可求出，此处复杂度为O(NM)。
那么这个例子求出来的h[][]就是

-> 1 0 1 0 0 
-> 2 0 2 1 1 
-> 3 1 3 2 2 
-> 4 0 0 3 0 

我们可以把每个数字看作是一个高度为h[i][j]的柱子。
遍历每一行，求出以该行为底，最大矩形面积为多少。
最后在所有行的答案中取一个最大值，即为最终答案。

那么我们只要求出一行中的最大面积即可。

---

以第三行举例：

3 1 3 2 2

假设我们求出两个数组l[]与r[]，用于表示第i个柱子最左边可以延长到的位置与最右边可以延长的位置，
也就是
l[i]保存比第i个柱子小的，在i左边的最接近i的柱子的下标。（若左边没有比i小的，则l[i] = -1）
r[i]保存比第i个柱子小的，在i右边的最接近i的柱子的下标。（若右边没有比i小的，则r[i] = len）
那么第三行对应的l[i]与r[i]为

下标为 0 到 len - 1 
h[] =  3  1 3 2 2

l[] = -1 -1 1 1 1
r[] =  1  5 3 5 5

当我们求出l[]与r[]的时候，我们可以算出对应i当前的高度的矩形面积为(r[i] - l[i] - 1) * h[i]。

---

那么问题就剩下一个：如何求出l[]与r[]。

• 不是很简单嘛，对于每个i，往左扫描求出l[i]，再往右扫描求出r[i]。
  这样的确很简单，但是对于每个数字，都需要左右扫描一遍，求出一行中的所有l[i]与r[i]，则是O(m * m)。再加上我们是一个矩形，有n行，那么复杂度就是O(n * m * m)。
• 单调栈
  单调栈是一个经典算法。在一个栈内维护一个单调的序列，可以为单调递增，也可以单调递减。
  在这个题目的背景中，我们的目标是，对于每一个i，找到他左边第一个比他小的。相反方向同理。

我们以一个方向举一个例子：如何求出l[]

对于每个i，从右往左看，我们只关心第一个小于当前高度的数字在什么位置，而不在乎更左边的数字是多少，也就是说，当有一个小的数字出现以后，再往左的大数字是没有意义的。
例如

h[] = 3 2 1 5 6

我们站在数字5的位置往左看。找到1以后就可以不必往左找了，再往左的2，3都是没有意义的。因为数字1限定了当前的上限。
那么我们在维护栈的时候，如果要入栈一个较小的数字，那么大于这个数字的所有数都可以出栈了。因为小的数字已经限定了高度的上限。
所以自然而然我们从左到右就维护出了一个递增序列。（还不明白就手算一下上面的h[]是如何计算l[]的）

用单调栈的原理，我们可以一遍扫描就求出l[]，复杂度O(m)。再反方向扫一遍求出r[]。
对于n行，每一行都这样求一次，总复杂度就为O(n * m)

---

代码

class Solution {
public:
    int maximalRectangle(vector<vector<char>>& matrix) {
        int n = matrix.size();
        if(n == 0) return 0;
        int m = matrix[0].size();
        if(m == 0) return 0;
        int dp[n + 10][m + 10] = {0};
        int h[n + 10][m + 10] = {0};
        for (int j = 0; j < m; j++) {
            for (int i = 0; i < n; i++) {
                if(i == 0){
                    h[i][j] = (matrix[i][j] == '1');
                } else {
                    h[i][j] = matrix[i][j] == '1' ? h[i - 1][j] + 1 : 0; 
                }
            }
        }
        int ans = 0;
        int l[m + 10] = {0};
        int r[m + 10] = {0};

        vector<int> st;
        for (int i = 0; i < n; i++) {
            st.clear();
            for (int j = 0; j < m; j++) {
                while(!st.empty() && h[i][st.back()] >= h[i][j]) {
                    st.pop_back();
                }
                if (st.empty()){
                    l[j] = -1;
                } else {
                    l[j] = st.back();
                }
                st.push_back(j); 
            }
            st.clear();
            for (int j = m - 1; j >= 0; j--) {
                while (!st.empty() && h[i][st.back()] >= h[i][j]) {
                    st.pop_back();
                }
                if (st.empty()) {
                    r[j] = m;
                } else {
                    r[j] = st.back();
                }
                st.push_back(j);
                ans = max(ans, (r[j] - l[j] - 1) * h[i][j]);
            }
        }
        return ans;
    }
};