最大矩形、柱状图的最大面积 C++

最大矩形问题分两种：一种是柱状图的面积，一种是给出一个矩阵，找出矩阵（点为1）的最大面积；图形分别如下：

后面一种可以转换成各行的柱状图的叠加；

柱状图

1	0	0	1
0	1	1	1
1	1	1	1
0	0	0	0

                                                                           矩阵

1、柱状图的最大面积

核心思想主要是使用单调栈，利用栈的后进先出;

单调栈的特点在于：
当遇见大数的时候， 压入堆栈，等待之后处理。
当遇见小数的时候，意味着大数的右边界已经确定了。

遍历整个柱状图，求出以每个下标为索引的高度为高度的最大矩形；只需找到这个柱子左边，右边第一个比它低的柱子;

int largestRectangleArea(vector<int>& heights)
{
    int ans = 0;
    vector<int> st;
    heights.insert(heights.begin(), 0);
    heights.push_back(0);
    for (int i = 0; i < heights.size(); i++)
    {
        while (!st.empty() && heights[st.back()] > heights[i])
        {
            int cur = st.back();
            st.pop_back();
            int left = st.back() + 1;
            int right = i - 1;
            ans = max(ans, (right - left + 1) * heights[cur]);
        }
        st.push_back(i);
    }
    return ans;
}

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        stack<int> st;
        heights.push_back(0);
         int maxarea = 0;
 // 对栈中柱体来说，栈中的下一个柱体就是其「左边第一个小于自身的柱体」；
 // 若当前柱体 i 的高度小于栈顶柱体的高度，说明 i 是栈顶柱体的「右边第一个小于栈顶柱体的柱体」。
 // 因此以栈顶柱体为高的矩形的左右宽度边界就确定了，可以计算面积

         for(int i = 0 ; i< heights.size(); i++)
         {
                while(!st.empty() && heights[i] < heights[st.top()])
                {
                    int top = st.top();
                    st.pop();//find the smaller element to the left of the current 
                                element
                    maxarea = max(maxarea, heights[top] * (st.empty()? i:(i-st.top()-1)));
                }
                st.push(i);
         }
         return maxarea;
    }         
};

相比于直方图最大矩形覆盖，只需要求出每一行作为底的最大矩形是多少，灭一行都有一个height组合，利用
单调栈，每次更新height数组，height数组代表的是这一列上面有多少个连续的1，即矩形的高度，以每一行
作为底（直方图最下面）时最大矩形面积，记录最大值；

类似于柱状图上述解法，如果栈中的数比当前的数大或者等于，就要处理栈顶的（记录左右两边的比它小的第一个数）

public int maximalRectangle(boolean[][] matrix){
  if ( matrix == null || matrix.length == 0 || matrix[0].length == 0){
     return 0; 
   }
  int ans = 0;
  int n = matrix.length, m = matrix[0].length;// row col
  int[][] dp = new int[n][m+1];

  for(int i = 0; i < n; i++){
    for(int j = 0; j < m;j++){
       if( i == 0&& matrix[i][j] ){
          dp[i][j] = 1;
          continue;
        }
       if(matrix[i][j]){
           dp[i][j] = dp[i-1][j] + 1;
         }
      }
   }
  
  for (int i = 0;i < n; i++){ //把每一行作为底找最大矩形
    ans = Math.max(ans, largestRectangleArea(dp[i]));
   }
return ans;
}

private int largestRectangleArea(int[] height){
   Stack<Integer> s = new Stack<>();
   height[height.length-1] = 0;
   int sum = 0;
   for(int i = 0; i < height.length; i++){
    
/*
  if(s.empty() || height[i] > height[s.peek()]){
         s.push(i);
      }
      else{
         int tmp = s.pop();
         sum = Math.max(sum, height[tmp] * (s.empty()?i:i-s.peek()-1));
         i--;  //拿着右边界，寻找左边界  与下面的st.push(i)一样；
       }

*/
/*
      while(!st.empty() && height[i] < height[st.peek()])
                {
                    int top = st.peek();
                    st.pop();//find the smaller element to the left of the current 
                                element
                    maxarea = max(maxarea, heights[top] * (st.empty()? i:(i-st.peek()-1)));
                }
                st.push(i);
*/
   }
   return sum;
}
}