LeetCode DAY51(503. Next Greater Element II&42. Trapping Rain Water)

Preface

This is a new day to continue my Monotonic stack journey.
Learn something new and keep reviewing what I learnt before.

1. Next Greater Element II

LeetCode Link: 503. Next Greater Element II

Given a circular integer array nums (i.e., the next element of nums[nums.length - 1] is nums[0]), return the next greater number for every element in nums.

The next greater number of a number x is the first greater number to its traversing-order next in the array, which means you could search circularly to find its next greater number. If it doesn’t exist, return -1 for this number.

Example 1:

Input: nums = [1,2,1]
Output: [2,-1,2]
Explanation: The first 1’s next greater number is 2;
The number 2 can’t find next greater number.
The second 1’s next greater number needs to search circularly, which is also 2.
Example 2:

Input: nums = [1,2,3,4,3]
Output: [2,3,4,-1,4]

Constraints:

1 <= nums.length <= 10^4
-10^9 <= nums[i] <= 10^9

Analysis and Solution

Monotonic stack

LeetCode C++ as followings Monotonic stack

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        vector<int> result(nums.size(), -1);//initialization == -1
        if (nums.size() == 0) return result;//remove case 0
        stack<int> st;
        st.push(0);
        for (int i = 1; i < nums.size() * 2; i++) { 
            //The simulation traverses nums on both sides, noting that they operate with i % nums.size().
            if (nums[i % nums.size()] < nums[st.top()]) st.push(i % nums.size());//case 1
            else if (nums[i % nums.size()] == nums[st.top()]) st.push(i % nums.size()); //case 2
            else {
                while (!st.empty() && nums[i % nums.size()] > nums[st.top()]) {//case 3
                    result[st.top()] = nums[i % nums.size()];
                    st.pop();
                }
                st.push(i % nums.size());
            }
        }
        return result;
    }
};

2. Trapping Rain Water

LeetCode Link: 42. Trapping Rain Water

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it can trap after raining.

Example 1:

Input: height = [0,1,0,2,1,0,1,3,2,1,2,1]
Output: 6
Explanation: The above elevation map (black section) is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped.
Example 2:

Input: height = [4,2,0,3,2,5]
Output: 9

Constraints:

n == height.length
1 <= n <= 2 * 10^4
0 <= height[i] <= 10^5

Analysis and Solution

Monotonic stack

LeetCode C++ as followings Monotonic stack

class solution {
public:
    int trap(vector<int>& height) {
        if (height.size() <= 2) return 0; // remove case 0
        stack<int> st; // save subscript
        st.push(0);
        int sum = 0;
        for (int i = 1; i < height.size(); i++) {
            if (height[i] < height[st.top()]) {     // case 1
                st.push(i);
            } if (height[i] == height[st.top()]) {  // case 2
                st.pop(); //remove element of same height with new element 
                st.push(i);//push the new element
            } else {                                // case 3
                while (!st.empty() && height[i] > height[st.top()]) { 
                    int mid = st.top();//save the height
                    st.pop();
                    if (!st.empty()) {
                        int h = min(height[st.top()], height[i]) - height[mid];//min(LeftHeight or RightHeight) - mid height
                        int w = i - st.top() - 1; // only mid height
                        sum += h * w;//sum = height * width
                    }
                }
                st.push(i);
            }
        }
        return sum;
    }
};