leetcode85 最大矩形（hard）

题目

给定一个仅包含 0 和 1 的二维二进制矩阵，找出只包含 1 的最大矩形，并返回其面积。

示例:

输入:
[
  ["1","0","1","0","0"],
  ["1","0","1","1","1"],
  ["1","1","1","1","1"],
  ["1","0","0","1","0"]
]
输出: 6

 

思路1：单调栈

这题还是比较有技巧性的，可以将它转换成，leetcode 84直方图最大矩形（https://leetcode.com/problems/largest-rectangle-in-histogram/），对于每一行将其作为以该行为底的一个直方图

这里计算最大矩形可以用单调栈：

1. 在高度数组（不是栈）最后面加上一个0，这样原先的最后一个板子也可以被处理

2.  0肯定比任何的heights都小，所以0放在heights最后，一定会计算最后一块板到前面板子的面积

3. 栈内存放下标，维护栈内是递增的高度

class Solution {
public:
    int maximalRectangle(vector<vector<char>>& matrix) {
        if(matrix.empty() || matrix[0].empty()) return 0;
        int m = matrix.size(),n = matrix[0].size(),max_num = 0;
        vector<vector<int>> heights(m,vector<int>(n+1,0));
        for(int j = 0;j < n;j++){
            if(matrix[0][j] == '1'){
                heights[0][j] = 1;
            }
        }
        for(int i = 1;i < m;i++){
            for(int j = 0;j < n;j++){
                if(matrix[i][j] == '1'){
                    heights[i][j] = heights[i-1][j]+1;
                }
            }
        }
        for(int i = 0;i < m;i++){
            max_num = max(max_num,process(heights,i));
        }
        return max_num;
    }

    int process(vector<vector<int>> &heights,int row){
        int col = heights[row].size();
        stack<int> s;
        int i = 0,max_num = 0;
        // 下面一段代码着重注意下
        while(i < col){
            if(s.empty() || heights[row][s.top()] < heights[row][i]){
                s.push(i);
                i++;
            }
            else{
                int cur = s.top();s.pop();
                max_num = max(max_num, heights[row][cur]*(s.empty()?i:(i-s.top()-1)));
            }
        }
        return max_num;
    }
};

 

思路2：暴力往前走

递增时，直接往后走

非递增时，往前回溯，逐个计算矩形面积

class Solution {
public:
    int maximalRectangle(vector<vector<char>>& matrix) {
        if(matrix.empty() || matrix[0].empty()) return 0;
        int m = matrix.size(),n = matrix[0].size(),max_num = 0;
        vector<vector<int>> heights(m,vector<int>(n+1,0));
        for(int j = 0;j < n;j++){
            if(matrix[0][j] == '1'){
                heights[0][j] = 1;
            }
        }
        for(int i = 1;i < m;i++){
            for(int j = 0;j < n;j++){
                if(matrix[i][j] == '1'){
                    heights[i][j] = heights[i-1][j]+1;
                }
            }
        }
        for(int i = 0;i < m;i++){
            max_num = max(max_num,process(heights,i));
        }
        return max_num;
    }

    int process(vector<vector<int>> &heights,int row){
        int col = heights[row].size();
        stack<int> s;
        int i = 0,max_num = heights[row][0];
        while(i < col){
            // 递增直接往后走
            while(i+1 < col && heights[row][i] < heights[row][i+1]) i++;
            // 非递增时，往前回溯，计算矩形面积
            int cur = heights[row][i];
            for(int j = i;j >= 0;j--){
                cur = min(cur,heights[row][j]);
                max_num = max(max_num,cur*(i-j+1));
            }
            i++;
        }
        return max_num;
    }
};