LeetCode（85）：最大矩形

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

解题思路：

此题是之前那道的Largest Rectangle in Histogram 直方图中最大的矩形 （http://www.cnblogs.com/grandyang/p/4322653.html）的扩展，这道题的二维矩阵每一层向上都可以看做一个直方图，输入矩阵有多少行，就可以形成多少个直方图，对每个直方图都调用http://www.cnblogs.com/grandyang/p/4322653.html中的方法，就可以得到最大的矩形面积。那么这道题唯一要做的就是将每一层构成直方图，由于题目限定了输入矩阵的字符只有 '0' 和 '1' 两种，所以处理起来也相对简单。方法是，对于每一个点，如果是‘0’，则赋0，如果是 ‘1’，就赋 之前的height值加上1。

C++解法一：

 class Solution {
 public:
     int maximalRectangle(vector<vector<char> > &matrix) {
         int res = ;
         vector<int> height;
         for (int i = ; i < matrix.size(); ++i) {
             height.resize(matrix[i].size());
             for (int j = ; j < matrix[i].size(); ++j) {
                 height[j] = matrix[i][j] == '' ?  : ( + height[j]);
             }
             res = max(res, largestRectangleArea(height));
         }
         return res;
     }
     int largestRectangleArea(vector<int> &height) {
         int res = ;
         stack<int> s;
         height.push_back();
         for (int i = ; i < height.size(); ++i) {
             if (s.empty() || height[s.top()] <= height[i]) s.push(i);
             else {
                 int tmp = s.top();
                 s.pop();
                 res = max(res, height[tmp] * (s.empty() ? i : (i - s.top() - )));
                 --i;
             }
         }
         return res;
     }
 };

我们也可以在一个函数内完成，这样代码看起来更加简洁一些：

C++解法二：

 class Solution {
 public:
     int maximalRectangle(vector<vector<char>>& matrix) {
         if (matrix.empty() || matrix[].empty()) return ;
         int res = , m = matrix.size(), n = matrix[].size();
         vector<int> height(n + , );
         for (int i = ; i < m; ++i) {
             stack<int> s;
             for (int j = ; j < n + ; ++j) {
                 if (j < n) {
                     height[j] = matrix[i][j] == '' ? height[j] +  : ;
                 }
                 while (!s.empty() && height[s.top()] >= height[j]) {
                     int cur = s.top(); s.pop();
                     res = max(res, height[cur] * (s.empty() ? j : (j - s.top() - )));
                 }
                 s.push(j);
             }
         }
         return res;
     }
 };

下面这种方法的思路很巧妙，height数组和上面一样，这里的left数组表示左边界是1的位置，right数组表示右边界是1的位置，那么对于任意一行的第j个位置，矩形为(right[j] - left[j]) * height[j]，我们举个例子来说明，比如给定矩阵为：

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

第0行：

h: 1 1 0 0 1
l: 0 0 0 0 4
r: 2 2 5 5 5 

第1行：

h: 1 1 0 0 1
l: 0 0 0 0 4
r: 2 2 5 5 5 

第2行：

h: 0 0 1 1 3
l: 0 0 2 2 4
r: 5 5 5 5 5

第3行：

h: 0 0 2 2 4
l: 0 0 2 2 4
r: 5 5 5 5 5

第4行：

h: 0 0 0 0 5
l: 0 0 0 0 4
r: 5 5 5 5 5 

C++解法三：

 class Solution {
 public:
     int maximalRectangle(vector<vector<char>>& matrix) {
         if (matrix.empty() || matrix[].empty()) return ;
         int res = , m = matrix.size(), n = matrix[].size();
         vector<int> height(n, ), left(n, ), right(n, n);
         for (int i = ; i < m; ++i) {
             int cur_left = , cur_right = n;
             for (int j = ; j < n; ++j) {
                 if (matrix[i][j] == '') ++height[j];
                 else height[j] = ;
             }
             for (int j = ; j < n; ++j) {
                 if (matrix[i][j] == '') left[j] = max(left[j], cur_left);
                 else {left[j] = ; cur_left = j + ;}
             }
             for (int j = n - ; j >= ; --j) {
                 if (matrix[i][j] == '') right[j] = min(right[j], cur_right);
                 else {right[j] = n; cur_right = j;}
             }
             for (int j = ; j < n; ++j) {
                 res = max(res, (right[j] - left[j]) * height[j]);
             }
         }
         return res;
     }
 };

我们也可以通过合并一些for循环，使得运算速度更快一些：

C++解法四：

 class Solution {
 public:
     int maximalRectangle(vector<vector<char>>& matrix) {
         if (matrix.empty() || matrix[].empty()) return ;
         int res = , m = matrix.size(), n = matrix[].size();
         vector<int> height(n, ), left(n, ), right(n, n);
         for (int i = ; i < m; ++i) {
             int cur_left = , cur_right = n;
             for (int j = ; j < n; ++j) {
                 if (matrix[i][j] == '') {
                     ++height[j];
                     left[j] = max(left[j], cur_left);
                 } else {
                     height[j] = ;
                     left[j] = ;
                     cur_left = j + ;
                 }
             }
             for (int j = n - ; j >= ; --j) {
                 if (matrix[i][j] == '') {
                     right[j] = min(right[j], cur_right);
                 } else {
                     right[j] = n;
                     cur_right = j;
                 }
                 res = max(res, (right[j] - left[j]) * height[j]);
             }
         }
         return res;
     }
 };