第54天-DP-第十章 单调栈 ● 503.下一个更大元素II（循环链表） ● 42. 接雨水

1. 下一个更大元素 II (这里循环链表 使用遍历两次数组的思想)

- 代码随想录链接

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        // 1.是一个循环的数组
        // 2.stack存放的是数组对应元素的下标
        vector<int> result(nums.size(), -1);
        if(nums.size() == 0) return result;

        stack<int> st;
        st.push(0);

        // 下一个更大的元素，这里因为是循环数组，所以需要先好左边的，再找右边的
        for(int i = 1; i < nums.size() * 2; i++){
            // 遍历的值小于等于 栈顶的元素
            if(nums[i % nums.size()] <= nums[st.top()]) st.push(i % nums.size());
            else{                      // 遍历的值大于栈顶的值
                while(!st.empty() && nums[i % nums.size()] > nums[st.top()]){
                    result[st.top()] = nums[i % nums.size()];
                    st.pop();
                }
                st.push(i % nums.size());  
            }
        }

        return result;
    }
};

2. 接雨水

- 代码随想录链接

暴力解法的优化，使用两个数组记录 每个元素左边和右边的最大值

class Solution {
public:
    // 暴力解法优化， 使用数组存储每个元素 左边第一个最大值maxLeft 和 右边第一个最大的值maxRight
    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 result = 0;
        for(int i=0; i<size; i++){
            int count = min(maxLeft[i], maxRight[i]) - height[i];
            result += count;
        }

        return result;
    }
};

• 单调栈解法

    
    // 单调栈
    int trap(vector<int>& height) {
        int result = 0;
        stack<int> st;
        st.push(0);

        for(int i=1; i<height.size(); i++){
            if(height[i] <= height[st.top()]) st.push(i);
            else{
                // 根据面积计算
                while(!st.empty() && height[st.top()] < height[i]){
                    // 雨水的面积是  长x宽   长=min(leftMax, rightMax) - height[st.top()]   宽 = (rightMax - leftMax - 1)
                    // 按照单调栈的特性， 栈内的元素是递增的，因此栈内相邻的两个元素要么相等，要么栈顶的小于下一个元素
                    int cur = st.top();     // 栈顶元素的下标
                    st.pop();
                    if(!st.empty()){
                        int maxHeight = min(height[i], height[st.top()]) - height[cur];
                        int width = i - st.top() - 1;
                        result += maxHeight * width;
                    }
                }
                st.push(i);
            }
        }

        return result;
    }