代码随想录 ｜ 单调栈 - 接雨水 + 柱状图最大的矩形

一、基本概念

1. 单调栈：单调栈是一种数据结构，其特点是栈内元素按插入顺序保持单调递增或递减，从而方便实现一些特殊类型的查询或操作。
2. 什么时候使用单调栈：通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，此时我们就要想到可以用单调栈了。时间复杂度为O(n)。
3. 如何使用：
   1. 决定弹出/压入的条件
   2. 决定弹出时完成任务的具体操作

二、题目

1. 接雨水：这道题本质找的是左右第一个更大的元素。
2. 柱状图最大的矩形：这道题本质找的是左右最小的元素。

三、代码

• 单调栈：

        以接雨水（以左边为栈底，右边为栈顶）为例

1. 压栈元素比栈顶元素大：进行计算操作，再压栈。根据单调栈的原理，对于栈顶元素，左边元素一定是比自己大，那遇到有比它大的元素的时候，就可以构成一个凹槽，也就是接雨水的当前列能接的水。
2. 压栈元素比栈顶元素小：压栈
3. 压栈元素等于栈顶元素： 弹出栈顶元素，压栈。
4. 压栈操作可以合并。

// 接雨水
class Solution {
public:
    int trap(vector<int>& height) {
        stack<int> stk;
        stk.push(0);
        int sum = 0;
        for(int i = 1; i < height.size(); i++){
            while(!stk.empty() && height[i] > height[stk.top()]){
                int mid = stk.top();
                stk.pop();
                if(!stk.empty()){
                    int h = min(height[stk.top()], height[i]) - height[mid];
                    int w = i - stk.top() - 1;
                    sum += h * w;
                }

            }
            stk.push(i);
        }
        return sum;
    }
};

// 柱状图
class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        stack<int> st;
        heights.insert(heights.begin(), 0); // 数组头部加入元素0
        heights.push_back(0); // 数组尾部加入元素0
        st.push(0);
        int result = 0;
        for (int i = 1; i < heights.size(); i++) {
            while (heights[i] < heights[st.top()]) {
                int mid = st.top();
                st.pop();
                int w = i - st.top() - 1;
                int h = heights[mid];
                result = max(result, w * h);
            }
            st.push(i);
        }
        return result;
    }
};

• 双指针法：比起暴力解法的核心在于通过创建两个指针数组，记录每个索引位置上第一个更小或更大的元素的索引。实现过程中，不是逐个遍历，而是通过“状态转移”，即查询当前索引的左右元素的第一个更小或更大的元素的索引，并更新当前索引的位置，直到遍历到左右端或找到目标元素。

// 接雨水
class Solution {
public:
    int trap(vector<int>& height) {
        if (height.size() <= 2) return 0;
        vector<int> maxLeft(height.size(), 0);
        vector<int> maxRight(height.size(), 0);
        int size = maxRight.size();

        // 记录每个柱子左边柱子最大高度
        maxLeft[0] = height[0];
        for (int i = 1; i < size; i++) {
            maxLeft[i] = max(height[i], maxLeft[i - 1]);
        }
        // 记录每个柱子右边柱子最大高度
        maxRight[size - 1] = height[size - 1];
        for (int i = size - 2; i >= 0; i--) {
            maxRight[i] = max(height[i], maxRight[i + 1]);
        }
        // 求和
        int sum = 0;
        for (int i = 0; i < size; i++) {
            int count = min(maxLeft[i], maxRight[i]) - height[i];
            if (count > 0) sum += count;
        }
        return sum;
    }
};

// 柱状图
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;
    }
};

四、时间复杂度

暴力解法：

双指针法：

单调栈：