代码随想录 | Day 59 - LeetCode 503. 下一个更大元素II、LeetCode 42. 接雨水

        今天是单调栈的第2天，第1道题是前面的延续，第2道题很难还常考。第2题双指针和DP解法重点是“当前位置的雨水量取决于左右两边柱子最高高度”，单调栈解法则要熟悉“左、中、右三个柱子各自的含义和作用”。

---

        第1题（LeetCode 503. 下一个更大元素II）相比day 58中第1题（LeetCode 739. 每日温度）变成了循环数组，且要求返回的结果是更大的数字本身，而不是下标的差值。对于循环数组，某个值更大的元素可能出现在其左边部分，最极端的情况是某个元素的更大值出现在与其相邻的左边。所以要遍历两次nums才能保证所有元素对应的值更大元素在其之后被遍历到。

        具体的做法有两种，第1种是将nums复制一份拼接在其后（代码如下），再用 day 58中第1题（LeetCode 739. 每日温度）中的方法遍历该数组。

vector<int> nums1(nums.begin(), nums.end());
nums.insert(nums.end(), nums1.begin(), nums1.end());

        第2种方法则是不占用额外空间，用下标取余数的方式来模拟两次遍历数组。这种方法更高效。

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        vector<int> res(nums.size(), -1);
        stack<int> st;
        st.push(0);
        for (int i = 0; i < 2 * nums.size(); ++i) {
            int ind = i % nums.size();
            if (nums[ind] <= nums[st.top()]) {
                st.push(ind);
            }
            else {
                while (!st.empty() && nums[ind] > nums[st.top()]) {
                    res[st.top()] = nums[ind];
                    st.pop();
                }
                st.push(ind);
            }
        }
        return res;
    }
};

---

        第2题（LeetCode 42. 接雨水）自己想了很久还是没想出，是一道高频考题需要注意。题解中有三种解法，分别是单调栈、双指针、DP解法。

        单调栈是三种方法中最难的一种，核心思想是维持单调递减的栈，在出现非递减元素时，弹出栈中元素的同时加雨水，每次所加的雨水数量都是其宽度和高度的乘积。当前元素与栈顶元素有小于、等于和大于3种情况：

1. 小于：为了维护单调递减关系，在遇到比栈顶元素更小值时将其下标入栈；
2. 等于：两者相等时应该将旧的元素出栈，更新为新元素下标，便于第3种情况中左柱子位置的确定。但其实只需让新元素入栈，不将旧元素弹出也不影响。因为新、旧元素只有下标不相等，值是相同的。所以如果新、旧元素中的某个要成为左柱子那么一定是新元素充当；如果新、旧元素中的某个要成为中间柱子，那么两者中哪个来充当效果都是一样的；最后因为两者想等，所以新元素出现后，两者都不会再充当右柱子；
3. 大于：将当前非递减元素、栈顶元素、栈顶元素的下一个元素分别定义为右、中、左柱子，那么当前需要加的雨水数量就由这三个柱子决定。当前与水的宽度就是（右柱子下标 - 左柱子下标 - 1）。减1是因为只计算中间凹陷处的雨水，不包含边缘。而高度需要取左、右柱子的较小值与中间柱子高度的差值。宽度与高度相乘就得到需要加的雨水数量。比如左、中、右柱子高度分别为[1, 0, 2]，下标分别为[0, 2, 3]（像下标1这样的情况是因为之前就被当做中间柱子而出栈），宽度就是(3 - 0 - 1) = 2，高度是(min(1, 2) - 0) = 1，所以雨水量是1 * 2 = 2。

        第3种情况的实现较为复杂，需要首先得到中间柱子，然后使其出栈，再得到左柱子，然后再计算宽度、高度，加雨水量。加完之后，有可能此时的栈顶元素，也就是左柱子，仍然小于当前非递减元素。所以要继续将其作为中柱子来重复上面的过程，所以这一过程要用while()来进行，其中的循环条件要首先保证栈非空，然后就是栈顶元素小于当前非递减元素。

// 单调栈
class Solution {
public:
    int trap(vector<int>& height) {
        int ans = 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 if (height[i] == height[st.top()]) {
                st.pop();
                st.push(i);
            }
            else {
                while (!st.empty() && height[i] > height[st.top()]) {
                    int mid = st.top();
                    st.pop();
                    if (!st.empty()) {
                        int w = i - st.top() - 1;
                        int h = min(height[i], height[st.top()]) - height[mid];
                        ans += w * h;
                    }
                }
                st.push(i);
            }
        }
        return ans;
    }
};

        双指针解法相对容易理解，但时间复杂度为O(n²)，较高，会超时。这里采用按列计算的方法，也就是单独计算每个位置的雨水高度。这个高度取决于当前位置左边部分的最高柱子、和右边部分最高柱子，两者中较小值，再减去当前位置的柱子高度，就是当前位置的雨水高度。所以需要在每个位置分别向左、右遍历，计算左、右两边的最高柱子高度。在遍历之前，可以将最高柱子高度初始化为当前柱子高度，这样一来，如果左边或右边没有更高的柱子，最后当前位置的雨水量就是0。最后需要注意最左边和最右边位置是不会接到雨水的，所以循环范围应该不包括左、右两端点。

// 双指针法，超时
class Solution {
public:
    int trap(vector<int>& height) {
        int ans = 0;
        for (int i = 1; i < height.size() - 1; ++i) {
            int leftMax = height[i], rightMax = height[i];
            for (int j = i - 1; j >= 0; --j) {
                leftMax = max(leftMax, height[j]);
            }
            for (int j = i + 1; j < height.size(); ++j) {
                rightMax = max(rightMax, height[j]);
            }
            ans += min(leftMax, rightMax) - height[i];
        }
        return ans;
    }
};

        DP解法沿用了上面双指针方法的思路，只不过会用DP方法提前一次性计算出每个位置左、右两边的最高柱子高度。dpLeft[i]、dpRight[i]分别定义为位置i左、右两边的最高柱子高度。对于位置i，其左边部分最高柱子高度要么是其左邻居的左边部分最高柱子高度，要么是自己本身，对应max(dp[i - 1], height[i])；同理其右边部分最高柱子高度对应max(dp[i + 1], height[i])。初始化部分，dpLeft最左端、dpRight最右端需要分别初始化为height的最左端、最右端值。其他部分与双指针法一致。

// DP
class Solution {
public:
    int trap(vector<int>& height) {
        vector<int> dpLeft(height.size()), dpRight(height.size());
        dpLeft[0] = height[0];
        dpRight[height.size() - 1] = height[height.size() - 1];
        for (int i = 1; i < height.size(); ++i) {
            dpLeft[i] = max(dpLeft[i - 1], height[i]);
        }
        for (int i = height.size() - 2; i >= 0; --i) {
            dpRight[i] = max(dpRight[i + 1], height[i]);
        }
        int ans = 0;
        for (int i = 1; i < height.size() - 1; ++i) {
            ans += min(dpLeft[i], dpRight[i]) - height[i];
        }
        return ans;
    }
};