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(n²)的解法实在是太显而易见了。

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

 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].length14                     && 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(n³)，所以没有通过大集合的测试。

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

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

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

代码如下：

 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. }