LeetCode | C++ 单调栈——503.下一个更大元素II、42. 接雨水

503.下一个更大元素II

503题目链接
本题容易想到的方法：将两个nums数组拼接在一起，然后使用单调栈计算每个元素对应的下一个最大值，最后把结果集缩小到原数组大小。

将两个数组拼接在一起，这样可以保证 对每个元素，都至少可遍历比较一圈nums

可以利用求余操作 来避免 空间上的开销

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        vector<int> result(nums.size(), -1);
        stack<int> st;
        for (int i = 0; i < 2 * nums.size(); i++) {
            int j = 0;
            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;
    }
};

42. 接雨水

42题目链接

暴力解法（双指针法）

按照列来计算，求出每一列雨水的高度，宽度为1， 高度之和即为 体积

每一列雨水的高度，取决于，该列 左侧最高的柱子 和 右侧最高的柱子中 最矮的那个柱子高度。

注意：第一个柱子 和 最后一个柱子不接雨水。

class Solution {
public:
    int trap(vector<int>& height) {
        int sum = 0;
        for (int i = 0; i < height.size(); i++) {
            if (i == 0 || i == height.size() - 1) continue;
            int rHeight = height[i];
            int lHeight = height[i];
            for (int j = i + 1; j < height.size(); j++) {
                if (height[j] > rHeight) rHeight = height[j];
            }
            for (int j = 0; j < i; j++) {
                if (height[j] > lHeight) lHeight = height[j];
            }
            int h = min(lHeight, rHeight) - height[i];
            if (h > 0) sum += h;
        }
        return sum;
    }
};

双指针法优化

可以对双指针法 进行优化

把每一个位置的左边最高高度和右边最高高度记录在一个数组上， 对于当前位置来说，左边最高 高度 是前一个的左边最高高度和本高度的最大值.

即 从左向右遍历：maxLeft[i] = max(height[i], maxLeft[i - 1]);

从右向左遍历：maxRight[i] = max(height[i], maxRight[i + 1]);

class Solution {
public:
    int trap(vector<int>& height) {
        int sum = 0;
        vector<int> maxLeft(height.size());
        maxLeft[0] = height[0];
        vector<int> maxRight(height.size());
        maxRight[height.size() - 1] = height[height.size() - 1];

        for (int i = 1; i < height.size(); i++) {
            maxLeft[i] = max(height[i], maxLeft[i - 1]);
        }
        for (int i = height.size() - 2; i >= 0; i--) {
            maxRight[i] = max(height[i], maxRight[i + 1]);
        }
        for (int i = 1; i < height.size() - 1; i++) {
            int h = min(maxLeft[i], maxRight[i]) - height[i];
            if (h > 0) sum += h;
        }
        return sum;
    }
};

单调栈

属于横向求解，按照行方向

使用递增顺序，当遇到 遍历元素 大于 栈顶元素时，即找到了 栈顶元素 的右边更大的元素，而对于栈顶元素 栈里面的下一个元素（即第二个元素），即为栈顶元素的 左边更大的元素。

这样就找到了一个凹槽，找到左右两边更大元素 的 最小值，减去 height[i]，即为 h, 左右两边更大元素 下标 相减 再 减 1， 即为 宽， 长 × 宽 即为体积。

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