leetcode84.柱状图的最大矩形

题目

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。

求在该柱状图中，能够勾勒出来的矩形的最大面积。
以上是柱状图的示例，其中每个柱子的宽度为 1，给定的高度为 [2,1,5,6,2,3]。

图中阴影部分为所能勾勒出的最大矩形面积，其面积为 10 个单位。

示例:

输入: [2,1,5,6,2,3]
输出: 10

解法1 暴力遍历

暴力遍历即列举出给定柱形图中所有可能的矩形。然后比较返回最大面积。

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int len = heights.size();
        int max_area  = 0;
        for(int i = 0 ; i < len;i++)
        {
            int min_height = heights[i];
            for(int j = i;j < len;j++)
            {
                min_height = min(min_height,heights[j]);
                max_area = max(max_area,(j - i + 1) * min_height);
            }
        }
        return max_area;
    }
};

时间复杂度 $O(n^2)$
空间复杂度 O(1)

解法2 分治法

摘自leetcode官方题解

通过观察，可以发现，最大面积矩形存在于以下几种情况：

1.确定了最矮柱子以后，矩形的宽尽可能往两边延伸。

2.在最矮柱子左边的最大面积矩形（子问题）。

3.在最矮柱子右边的最大面积矩形（子问题）。

对于情况1,确定了最矮的矩形也就确定了从最矮矩形往两边延申的高度,所以当长度最长为(end - start + 1)
时候,面积最大.

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        return Divide(heights,0,heights.size() - 1);
    }

    int Divide(vector<int> heights, int start,int end)
    {
        if(start == end)
            return heights[start];
        if(start > end)
            return 0;
        int min_height = heights[start];
        int min_index = start;
        for(int i = start; i <= end;i++)
        {
            if(heights[i] < min_height)
            {
                min_height = heights[i];
                min_index = i;
            }
        }
            int case1 = (end - start + 1) * min_height;  //从最矮矩形向两侧延伸
            int case2 = Divide(heights,start,min_index - 1); //左边子问题
            int case3 = Divide(heights,min_index + 1,end); //右侧子问题.
            return max(case1,max(case2,case3));
    }
};

平均时间复杂度$O(nlogn)$
最坏情况下(严格排序数组)会退化成$O(n^2)$ leetcode有一个1-20000的严格升序数组样例(= =)
空间复杂度O(n) 最坏情况下递归会有n层.

解法3 单调栈

参考这位大佬的博客：
柱状图中最大的矩形/C++
维护一个单调栈，首先在数组末尾插入一个数值为0的元素来方便末尾矩形的计算。
单调栈的栈顶为最大元素。
以此遍历数组中的元素：
1.当栈为空时，插入当前元素。
2.当当前元素比栈顶的元素大时，插入当前元素。
3.当当前元素比栈顶元素来得小时，依次弹出比当前元素大的数值，并计算以弹出元素高度为宽的矩形。
弹出元素为宽的矩形右边界为遍历的当前元素，左边界为弹出后的新栈顶。

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        stack <int> stack_arr;
        int max_area = 0;
        heights.push_back(0);
        int len = heights.size();
        for(int i = 0; i < len ;i++)
        {
            while(!stack_arr.empty() && heights[i] < heights[stack_arr.top()])
            {
                int top = stack_arr.top();
                stack_arr.pop();
                max_area = max(max_area,heights[top] * (stack_arr.empty()?i:i - stack_arr.top() - 1));
            }
            stack_arr.push(i);
        }
        return max_area;
    }
};

不知道怎么证明算法，大致记下来吧。。
时间复杂度 $O(n)$
空间复杂度 $O(n)$