个人中心
gpt4 book ai didi

C++实现LeetCode(85.最大矩形)

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 29 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章C++实现LeetCode(85.最大矩形)由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

[LeetCode] 85. 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. 。

Example

Input: [ ["1","0","1","0","0"], ["1","0","1","1","1"], ["1","1","1","1","1"], ["1","0","0","1","0"] ] Output: 6 。

此题是之前那道的 Largest Rectangle in Histogram 的扩展，这道题的二维矩阵每一层向上都可以看做一个直方图，输入矩阵有多少行，就可以形成多少个直方图，对每个直方图都调用 Largest Rectangle in Histogram 中的方法，就可以得到最大的矩形面积。那么这道题唯一要做的就是将每一层都当作直方图的底层，并向上构造整个直方图，由于题目限定了输入矩阵的字符只有 '0' 和 '1' 两种，所以处理起来也相对简单。方法是，对于每一个点，如果是 ‘0'，则赋0，如果是 ‘1'，就赋之前的 height 值加上1。具体参见代码如下:

解法一:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class Solution {
public :
     int maximalRectangle(vector<vector< char > > &matrix) {
         int res = 0;
         vector< int > height;
         for ( int i = 0; i < matrix.size(); ++i) {
             height.resize(matrix[i].size());
             for ( int j = 0; j < matrix[i].size(); ++j) {
                 height[j] = matrix[i][j] == '0' ? 0 : (1 + height[j]);
             }
             res = max(res, largestRectangleArea(height));
         }
         return res;
     }
     int largestRectangleArea(vector< int >& height) {
         int res = 0;
         stack< int > s;
         height.push_back(0);
         for ( int i = 0; 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() - 1)));
                 --i;
             }
         }
         return res;
     }
};

我们也可以在一个函数内完成，这样代码看起来更加简洁一些，注意这里的 height 初始化的大小为 n+1，为什么要多一个呢？这是因为我们只有在当前位置小于等于前一个位置的高度的时候，才会去计算矩形的面积，假如最后一个位置的高度是最高的，那么我们就没法去计算并更新结果 res 了，所以要在最后再加一个高度0，这样就一定可以计算前面的矩形面积了，这跟上面解法子函数中给 height 末尾加一个0是一样的效果，参见代码如下:

解法二:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Solution {
public :
     int maximalRectangle(vector<vector< char >>& matrix) {
         if (matrix.empty() || matrix[0].empty()) return 0;
         int res = 0, m = matrix.size(), n = matrix[0].size();
         vector< int > height(n + 1);
         for ( int i = 0; i < m; ++i) {
             stack< int > s;
             for ( int j = 0; j < n + 1; ++j) {
                 if (j < n) {
                     height[j] = matrix[i][j] == '1' ? height[j] + 1 : 0;
                 }
                 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() - 1)));
                 }
                 s.push(j);
             }
         }
         return res;
     }
};

下面这种方法的思路很巧妙，height 数组和上面一样，这里的 left 数组表示若当前位置是1且与其相连都是1的左边界的位置（若当前 height 是0，则当前 left 一定是0），right 数组表示若当前位置是1且与其相连都是1的右边界的位置再加1（加1是为了计算长度方便，直接减去左边界位置就是长度），初始化为n（若当前 height 是0，则当前 right 一定是n），那么对于任意一行的第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: 0 2 0 0 2 。

l: 0 1 0 0 4  。

r: 5 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 。

解法三:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class Solution {
public :
     int maximalRectangle(vector<vector< char >>& matrix) {
         if (matrix.empty() || matrix[0].empty()) return 0;
         int res = 0, m = matrix.size(), n = matrix[0].size();
         vector< int > height(n, 0), left(n, 0), right(n, n);
         for ( int i = 0; i < m; ++i) {
             int cur_left = 0, cur_right = n;
             for ( int j = 0; j < n; ++j) {
                 if (matrix[i][j] == '1' ) {
                     ++height[j];
                     left[j] = max(left[j], cur_left);
                 } else {
                     height[j] = 0;
                     left[j] = 0;
                     cur_left = j + 1;
                 }
             }
             for ( int j = n - 1; j >= 0; --j) {
                 if (matrix[i][j] == '1' ) {
                     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;
     }
};

再来看一种解法，这里我们统计每一行的连续1的个数，使用一个数组 h_max, 其中 h_max[i][j] 表示第i行，第j个位置水平方向连续1的个数，若 matrix[i][j] 为0，那对应的 h_max[i][j] 也一定为0。统计的过程跟建立累加和数组很类似，唯一不同的是遇到0了要将 h_max 置0。这个统计好了之后，只需要再次遍历每个位置，首先每个位置的 h_max 值都先用来更新结果 res，因为高度为1也可以看作是矩形，然后我们向上方遍历，上方 (i, j-1) 位置也会有 h_max 值，但是用二者之间的较小值才能构成矩形，用新的矩形面积来更新结果 res，这样一直向上遍历，直到遇到0，或者是越界的时候停止，这样就可以找出所有的矩形了，参见代码如下:

解法四:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Solution {
public :
     int maximalRectangle(vector<vector< char >>& matrix) {
         if (matrix.empty() || matrix[0].empty()) return 0;
         int res = 0, m = matrix.size(), n = matrix[0].size();
         vector<vector< int >> h_max(m, vector< int >(n));
         for ( int i = 0; i < m; ++i) {
             for ( int j = 0; j < n; ++j) {
                 if (matrix[i][j] == '0' ) continue ;
                 if (j > 0) h_max[i][j] = h_max[i][j - 1] + 1;
                 else h_max[i][0] = 1;
             }
         }
         for ( int i = 0; i < m; ++i) {
             for ( int j = 0; j < n; ++j) {
                 if (h_max[i][j] == 0) continue ;
                 int mn = h_max[i][j];
                 res = max(res, mn);
                 for ( int k = i - 1; k >= 0 && h_max[k][j] != 0; --k) {
                     mn = min(mn, h_max[k][j]);
                     res = max(res, mn * (i - k + 1));
                 }
             }
         }
         return res;
     }
};

到此这篇关于C++实现LeetCode(85.最大矩形)的文章就介绍到这了,更多相关C++实现最大矩形内容请搜索我以前的文章或继续浏览下面的相关文章希望大家以后多多支持我！ 。

原文链接：https://www.cnblogs.com/grandyang/p/4322667.html 。

最后此篇关于C++实现LeetCode(85.最大矩形)的文章就讲到这里了,如果你想了解更多关于C++实现LeetCode(85.最大矩形)的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

29 4 0
文章推荐： 再见 Docker如何5分钟转型 containerd
文章推荐： React实现全选功能
文章推荐： Docker镜像的导入导出代码实例
文章推荐： react实现复选框全选和反选组件效果
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com