LeetCode 84:柱状图中最大的矩形（困难）

LeetCode 84:柱状图中最大的矩形

解答

这两道单调栈的题目需要好好反思一下，为什么思路大体正确但是都没有做出来

代码一

思路一模仿接雨水中双指针的方法，

• 接雨水中是要找到 val 左右两侧中最高的柱子，取min得到水平面高度
• 本题中是要找到val 往左往右拓展， 尽可能往左/往右 大于等于 val的柱子索引，这个就是计算宽度，高度就是val
  好像都是根据val， 找到宽的制约因素。这个思路自己想出来了，但是没有写代码，因为最坏情况复杂度为O(n^2)，

但是下面的代码复杂度应该略高于O(n)，while部分的复杂度不好分析，使用了并查集记录，空间换时间，heights[t] >= heights[i]时，heigits[t]高于heights[i]，heights[t]左边第一个小于该柱子的柱子minLeftIndex[t]，有可能高于heights[i],有可能低于heights[i]，

• 如果低于heights[i]，则minLeftIndex[t]到heights[i]的区间内没有低于heights[t]的柱子了，全是高于heights[t] (heights[t] >= heights[i])的柱子，所以minLeftIndex[i] = t；
• 如果高于heights[i]，那么重复上述过程
  

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        vector<int> minLeftIndex(heights.size());
        vector<int> minRightIndex(heights.size());
        int size = heights.size();

        // 记录每个柱子 左边第一个小于该柱子的下标
        minLeftIndex[0] = -1; // 注意这里初始化，防止下面while死循环
        for (int i = 1; i < size; i++) {
            int t = i - 1;
            // 这里不是用if，而是不断向左寻找的过程
            while (t >= 0 && heights[t] >= heights[i]) t = minLeftIndex[t];
            minLeftIndex[i] = t;
        }
        // 记录每个柱子 右边第一个小于该柱子的下标
        minRightIndex[size - 1] = size; // 注意这里初始化，防止下面while死循环
        for (int i = size - 2; i >= 0; i--) {
            int t = i + 1;
            // 这里不是用if，而是不断向右寻找的过程
            while (t < size && heights[t] >= heights[i]) t = minRightIndex[t];
            minRightIndex[i] = t;
        }
        // 求和
        int result = 0;
        for (int i = 0; i < size; i++) {
            int sum = heights[i] * (minRightIndex[i] - minLeftIndex[i] - 1);
            result = max(sum, result);
        }
        return result;
    }
};

代码二

自己一开始思考的是找到 尽可能往左/往右 大于等于 val的柱子索引，因为想尽可能往左往右拓展。

但是考虑单调递减栈（从栈顶到栈底递减），比如1，3，5，每个元素的下一个（从栈顶到栈底）都是左边小于该元素的第一个（在入栈时，进行必要的出栈后，栈顶元素的右边第一个比自己大的数是当前元素，同样，当前元素的左边的第一个比自己小的数是栈顶，然后当前元素入栈）。实际上就是在一维数组中对每一个数找到第一个比自己小的元素。 用大于等于 val的柱子考虑就不太合适了。

考虑一个单调递减栈，比如1，3，2，当1，3入栈后，2要入栈时，此时对于3而言，左边第一个小于3的元素是1，右边第一个小于3的元素是2，3找到了左右边界。

在比如1，2，3，当1，2入栈后，3入栈时，此时对于2而言，左边第一个小于2的元素是1，右边第一个小于2的元素还未知（因为3可以直接入栈）。

也就是当前可以计算的是出栈元素柱子的最大矩形

核心是单调栈的用途：
左边/右边 找到第一个比自己 大/小 的元素

上面写的比较乱，拿例子举例就清晰一点了

从左往右，从栈顶到栈底递减：1，3，5，4 ，2， 找到左边/右边 第一个小于自己的元素，注意now=4时，5要出栈，左边是栈内的3，右边是now=4，注意4左边第一个比自己小的是3，出栈元素5右边第一个比自己小的是4
从左往右，从栈顶到栈底递增：5，3，1，2 ，4， 找到左边/右边 第一个大于自己的元素

// my solution
class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        stack<int> st;
        int now=0, left=0, right=0, mid=0, ans=0;
        for(int i=0; i<heights.size(); i++){
            now = heights[i];
            if(st.empty()) st.push(i);
            else if(now > heights[st.top()]) st.push(i);
            else if(now == heights[st.top()]) {// 因为找到是左边第一个小于val的元素索引
                st.pop();
                st.push(i);
            }
            else{ // now < heights[st.top()]， 比如：1，3，2
                while(!st.empty() && now < heights[st.top()]){
                    mid = st.top();
                    st.pop();
                    if(st.empty()) { // heights[mid]左边没有
                        ans = max(ans, (i-0)*heights[mid]);
                        break;
                    }
                    right = i;
                    left = st.top();
                    ans = max(ans, (right-left-1)*heights[mid]);
                }
                st.push(i);
            }
        }

        right = heights.size();
        while(!st.empty()){
            mid = st.top();
            st.pop();
            if(st.empty()){
                ans = max(ans, (int)(heights[mid] * heights.size() ));
                break;
            }
            
            left = st.top();
            ans = max(ans, (right-left-1)*heights[mid]);
            // right = left;
        }
        return ans;
    }
};

代码三

与代码一类似，同样是往左往右找第一个小于该元素的柱子，使用上述描述的单调递减栈（从栈顶到栈底递减）
从左往右使用递减栈找到每个元素左边第一个小于该元素的值，从右往左使用递减栈找到每个元素右边第一个小于该元素的值
每个元素至多入栈一次，出栈一次，所以复杂度为O(n)

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int n = heights.size();
        vector<int> left(n), right(n);
        
        stack<int> mono_stack;
        for (int i = 0; i < n; ++i) {
            while (!mono_stack.empty() && heights[mono_stack.top()] >= heights[i]) {
                mono_stack.pop();
            }
            left[i] = (mono_stack.empty() ? -1 : mono_stack.top());
            mono_stack.push(i);
        }

        mono_stack = stack<int>();
        for (int i = n - 1; i >= 0; --i) {
            while (!mono_stack.empty() && heights[mono_stack.top()] >= heights[i]) {
                mono_stack.pop();
            }
            right[i] = (mono_stack.empty() ? n : mono_stack.top());
            mono_stack.push(i);
        }
        
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            ans = max(ans, (right[i] - left[i] - 1) * heights[i]);
        }
        return ans;
    }
};

小结

核心问题是找到左边右边第一个小于该元素的索引（注意不是大于等于），熟悉单调栈后应该比较自然的想到代码三的思路，从左往右、从右往左遍历两遍
代码二的思路是，从左往右遍历一遍，就可以同时确定 每个元素左边右边第一个小于该元素的索引，(eg：从左往右，从栈顶到栈底递减：1，3，5，4 ，2)，