Largest Rectangle in Histogram&&Maximal Rectangle

题目: Largest Rectangle in Histogram

Given n non-negative integers representing the histogram's bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.

Above is a histogram where width of each bar is 1, given height = [2,1,5,6,2,3].

 

The largest rectangle is shown in the shaded area, which has area = 10 unit.

For example,
Given height = [2,1,5,6,2,3],
return 10.

解法一: 这样的题目一般都有O(n)的解法,因为O(n2)的解法实在是太显而易见了。

可悲的是,本娃就只写出了后者。。。代码如下:

复制代码
 1 public int largestRectangleArea(int[] height) {
 2         // Start typing your Java solution below
 3         // DO NOT write main() function
 4         int[] min = new int[height.length];
 5         int maxArea = 0;
 6         for(int i = 0; i < height.length; i++){
 7             if(height[i] != 0 && maxArea/height[i] >= (height.length - i)) {
 8                 continue;
 9             }
10             for(int j = i; j < height.length; j++){
11                 if(i == j) min[j] = height[j];
12                 else {
13                     if(height[j] < min[j - 1]) {
14                         min[j] = height[j];
15                     }else min[j] = min[j-1];
16                 }
17                 int tentativeArea = min[j] * (j - i + 1);
18                 if(tentativeArea > maxArea) {
19                     maxArea = tentativeArea;
20                 }
21             }
22         }
23         return maxArea;
24     }
复制代码

基本思想就是遍历所有[i, j],并在过程中找出中间最矮的bar,得出从i到j的矩形面积。

不过我就知道,一定有大神用他们极简的代码来切题,下面就是一个。

解法二:

复制代码
 1 public int largestRectangleArea2(int[] height) {
 2         Stack<Integer> stack = new Stack<Integer>();
 3         int i = 0;
 4         int maxArea = 0;
 5         int[] h = new int[height.length + 1];
 6         h = Arrays.copyOf(height, height.length + 1);
 7         while(i < h.length){
 8             if(stack.isEmpty() || h[stack.peek()] <= h[i]){
 9                 stack.push(i++);
10             }else {
11                 int t = stack.pop();
12                 maxArea = Math.max(maxArea, h[t] * (stack.isEmpty() ? i : i - stack.peek() - 1));
13             }
14         }
15         return maxArea;
16     }
复制代码

16行,给跪了。。。。

这个我不去debug下都特么不知道在干嘛。

那要不就debug下看看这段代码在做神马。例子就用题目中的[2,1,5,6,2,3]吧。

首先,如果栈是空的,那么索引i入栈。那么第一个i=0就进去吧。注意栈内保存的是索引,不是高度。然后i++。

然后继续,当i=1的时候,发现h[i]小于了栈内的元素,于是出栈。(由此可以想到,哦,看来stack里面只存放单调递增的索引

这时候stack为空,所以面积的计算是h[t] * i.t是刚刚弹出的stack顶元素。也就是蓝色部分的面积。

继续。这时候stack为空了,继续入栈。注意到只要是连续递增的序列,我们都要keep pushing,直到我们遇到了i=4,h[i]=2小于了栈顶的元素。

这时候开始计算矩形面积。首先弹出栈顶元素,t=3。即下图绿色部分。

接下来注意到栈顶的(索引指向的)元素还是大于当前i指向的元素,于是出栈,并继续计算面积,桃红色部分。

最后,栈顶的(索引指向的)元素大于了当前i指向的元素,循环继续,入栈并推动i前进。直到我们再次遇到下降的元素,也就是我们最后人为添加的dummy元素0.

同理,我们计算栈内的面积。由于当前i是最小元素,所以所有的栈内元素都要被弹出并参与面积计算。

注意我们在计算面积的时候已经更新过了maxArea。

总结下,我们可以看到,stack中总是保持递增的元素的索引,然后当遇到较小的元素后,依次出栈并计算栈中bar能围成的面积,直到栈中元素小于当前元素。

可是为什么这个方法是正确的呢? 我也没搞清楚。只是觉得不明觉厉了。

 -------------------------------------------------更新----------------------------------------------------------------

可以这样理解这个算法,看下图。

例如我们遇到最后遇到一个递减的bar(红色)。高度位于红线上方的(也就是算法中栈里面大于最右bar的)元素,他们是不可能和最右边的较小高度bar围成一个比大于在弹栈过程中的矩形面积了(黄色面积),因为红色的bar对他们来说是一个短板,和红色bar能围成的最大面积也就是红色的高度乘以这些“上流社会”所跨越的索引范围。但是“上流社会”的高度个个都比红色bar大,他们完全只计算彼此之间围成的面积就远远大于和红色bar围成的任意面积了。所以红色bar是不可能参与“上流社会”的bar的围城的(好悲哀)。

但是屌丝也不用泄气哦。因为虽然长度不占优势,但是团结的力量是无穷的。它还可以参与“比较远的”比它还要屌丝的bar的围城。他们的面积是有可能超过上流社会的面积的,因为距离啊!所以弹栈到比红色bar小就停止了。

另外一个细节需要注意的是,弹栈过程中面积的计算。

h[t] * (stack.isEmpty() ? i : i - stack.peek() - 1)

h[t]是刚刚弹出的栈顶端元素。此时的面积计算是h[t]和前面的“上流社会”能围成的最大面积。这时候要注意哦,栈内索引指向的元素都是比h[t]小的,如果h[t]是目前最小的,那么栈内就是空哦。而在目前栈顶元素和h[t]之间(不包括h[t]和栈顶元素),都是大于他们两者的。如下图所示:

那h[t]无疑就是Stack.Peek和t之间那些上流社会的短板啦,而它们的跨越就是i - Stack.Peek - 1。

所以说,这个弹栈的过程也是维持程序不变量的方法啊:栈内元素一定是要比当前i指向的元素小的。

----------------------------------------------------------------------------------华丽------------------------------------------------------------------------------------------------------------------------

我只想问算法的作者,他们到底是怎么想出来的,在这么短的时间内。是不是有一些类似的研究或者算法给他们以灵感?

太有画面感了有木有!

===============================

题目: Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing all ones and return its area.

leetcode的题目真是越来越经典了。比如这个题目,就是一道男默女泪的题。

一般人拿到这个题目,除非做过类似的,很难一眼找出一个方法来,更别说找一个比较优化的方法了。

首先一个难点就是,你怎么判断某个区域就是一个矩形呢?

其次,以何种方式来遍历这个2D的matrix呢?

一般来说,对这种“棋盘式”的题目,像什么Queen啦,象棋啦,数独啦,如果没有比较明显的遍历方式,可以采用一行一行地遍历。(好像废话哦。。。)

然后,当遍历到(i, j)的时候,该做什么样的事情呢?想想,嗯,那我可不可以简单看看,以(i,j)为矩形左上角,能不能形成一个矩形,能不能形成多个矩形?那形成的矩形中,我们能不能找一个最大的呢?(有同学问,为毛你要以这个点为左上角,不为左下角,或者其他脚哩?因为我们打算从左到右,从上到下一行一行遍历嘛,这样就不会漏掉,说不定还能做一些优化)

首先,如果(i, j)是0,那肯定没法是矩形了。

如果是1,那么我们怎么找以它为左上角的矩形呢?呼唤画面感!

。。。你TM在逗我?==b

图中圈圈表示左上角的1,那么矩形的可能性是。。。太多啦,怎么数嘛!

我们可以试探地从左上角的1所在的列开始,往下数数,然后呢,比如在第一行,例如是蓝色的那个矩形,我们看看在列上,它延伸了多远,这个面积是可以算出来的。

然后继续,第二行,例如是那个红色的矩形,再看它延伸到多远,哦,我们知道,比第一行近一些,我们也可以用当前离第一行的行数,乘以延伸的距离,得到当前行表示的矩形面积。

但是到了第一个虚线的地方,它远远超过了上面的其他所有行延伸的距离了,注意它的上方都是空心的哦,所以,我们遇到这种情况,计算当前行和左上角1围成的面积的时候,只能取所有前面最小的延伸距离乘以当前离第一行的行数。其实,这对所有情况都是这样的,是吧?于是,我们不是就有方法遍历这些所有的矩形了嘛。

代码如下:

复制代码
 1     /**
 2      * 以给出的坐标作为左上角,计算其中的最大矩形面积
 3      * @param matrix
 4      * @param row 给出坐标的行
 5      * @param col 给出坐标的列
 6      * @return 返回最大矩形的面积
 7      */
 8     private int maxRectangle(char[][] matrix, int row, int col) {
 9         int minWidth = Integer.MAX_VALUE;
10         int maxArea = 0;
11         for (int i = row; i < matrix.length && matrix[i][col] == '1'; i++) {
12             int width = 0;
13             while (col + width < matrix[row].length
14                     && matrix[i][col + width] == '1') {
15                 width++;
16             }
17             if (width < minWidth) {// 如果当前宽度小于了以前的最小宽度,更新它,为下面的矩形计算做准备
18                 minWidth = width;
19             }
20             int area = minWidth * (i - row + 1);
21             if (area > maxArea)
22                 maxArea = area;
23         }
24         return maxArea;
25     }
复制代码

这样,我们再对每个点都调用一下上面的这个方法,不是就能求出最大面积了么。

解法一:

复制代码
public int maximalRectangle(char[][] matrix) {
        // Start typing your Java solution below
        // DO NOT write main() function
        int m = matrix.length;
        int n = m == 0 ? 0 : matrix[0].length;
        int maxArea = 0;
        for(int i = 0; i < m; i++){//row
            for(int j = 0; j < n; j++){//col
                if(matrix[i][j] == '1'){
                    int area = maxRectangle(matrix, i, j);
                    if(area > maxArea) maxArea = area;
                }
            }
        }
        return maxArea;
     }
复制代码

这个需要O(n3),所以没有通过大集合的测试。

leetcode的讨论组给出了一个比较难理解的方法,这里就不采用了。

说说第三个方法。前一个笔记,我们讨论了柱状图的最大矩形面积,那可以O(n)的,学以致用呀!btw,leetcode的这两题也是挨一块儿的,用心良苦。。。。

如果我们把每一行看成x坐标,那高度就是从那一行开始往上数的1的个数。带入我们的maxAreaInHist方法,在O(n2)时间内就可以求出每一行形成的“柱状图”的最大矩形面积了。它们之中最大的,就是我们要的答案。

代码如下:

复制代码
 1 public int maximalRectangle2(char[][] matrix) {
 2         int m = matrix.length;
 3         int n = m == 0 ? 0 : matrix[0].length;
 4         int[][] height = new int[m][n + 1];
 5         //actually we know that height can just be a int[n+1], 
 6         //however, in that case, we have to write the 2 parts together in row traverse,
 7         //which, leetcode just doesn't make you pass big set
 8         //所以啊,leetcode是喜欢分开写循环的,即使时间复杂度一样,即使可以节约空间
 9         int maxArea = 0;
10         for(int i = 0; i < m; i++){
11             for(int j = 0; j < n; j++) {
12                 if(matrix[i][j] == '0'){
13                     height[i][j] = 0;
14                 }else {
15                     height[i][j] = i == 0 ? 1 : height[i - 1][j] + 1;
16                 }
17             }
18         }
19         for(int i = 0; i < m; i++){
20             int area = maxAreaInHist(height[i]);
21             if(area > maxArea){
22                 maxArea = area;
23             }
24         }
25         return maxArea;
26      }
27      
28      private int maxAreaInHist(int[] height){
29          Stack<Integer> stack = new Stack<Integer>();
30          int i = 0;
31          int maxArea = 0;
32          while(i < height.length){
33              if(stack.isEmpty() || height[stack.peek()] <= height[i]){
34                  stack.push(i++);
35              }else {
36                  int t = stack.pop();
37                  maxArea = Math.max(maxArea, height[t] * (stack.isEmpty() ? i : i - stack.peek() - 1));
38              }
39          }
40          return maxArea;
41      }
复制代码

这里有一个和leetcode相关的细节。就是本来在计算height数组的时候,我们没有必要分配成代码中的那个样子,一维就可以了,然后在遍历每一行的时候计算当前行的height数组,然后再计算maxArea。这种情况下还是过不了大集合,所以不得不为每一行都保存一个height,先期计算该二维数组。

总结:

1. 学到的新知识要用;

2. 画面感和逻辑分析都很重要,不可偏非。


============================


一群高度不完全相同的牛从左到右站成一排,每头牛只能看见它右边的比它矮的牛的发型,若遇到一头高度大于或等于它的牛,则无法继续看到这头牛后面的其他牛。

给出这些牛的高度,要求每头牛可以看到的牛的数量的和。

把要求作一下转换,其实就是要求每头牛被看到的次数之和。这个可以使用单调栈来解决。

从左到右依次读取当前牛的高度,从栈顶开始把高度小于或等于当前牛的高度的那些元素删除,此时栈中剩下的元素的数量就是可以看见当前牛的其他牛的数量。把这个数量加在一起,就可以得到最后的答案了。

[cpp]  view plain  copy
  1. #include <iostream>  
  2. #include <cstdio>  
  3. using namespace std;  
  4.   
  5. const int N = 80005;  
  6. int stack[N];  
  7. int top, n;  
  8.   
  9. int main()  
  10. {  
  11.     int num;  
  12.     long long ans = 0;  
  13.     scanf("%d", &n);  
  14.     for (int i = 0; i < n; ++i)  
  15.     {  
  16.         scanf("%d", &num);  
  17.         while (top > 0 && stack[top - 1] <= num) --top;  
  18.         ans += top;  
  19.         stack[top++] = num;  
  20.     }  
  21.     printf("%lld\n", ans);  
  22.     return 0;  
  23. }  
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值