代码随想录算法训练营第五十九天|● 503.下一个更大元素II ● 42. 接雨水

合集 - 代码训练(55)

51.代码随想录算法训练营第五十九天|● 503.下一个更大元素II ● 42. 接雨水2024-03-28

52.代码随想录算法训练营第六十天|● 84.柱状图中最大的矩形2024-03-28 53.每日一题： 2192. 有向无环图中一个节点的所有祖先2024-04-04 54.每日一题：1026. 节点与其祖先之间的最大差值2024-04-05 55.每日一题：1483. 树节点的第 K 个祖先2024-04-06

下一个更大元素II

题目链接：503. 下一个更大元素 II - 力扣（LeetCode）

思路：这里处理循环数组的方式值得学习，用i%nums.size()和for循环的上限来模拟两层for循环。整体思路还是单调栈。

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        vector<int> result(nums.size(),-1);
        stack<int> dd;
        dd.push(0);
        for(int i=0;i<nums.size()*2;i++){
            while(!dd.empty()&&nums[i%nums.size()]>nums[dd.top()]){
                result[dd.top()]=nums[i%nums.size()];
                dd.pop();
            }
            dd.push(i%nums.size());
        }
        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 trap(vector<int>& height) {
        if (height.size() <= 2) return 0; // 可以不加
        stack<int> st; // 存着下标，计算的时候用下标对应的柱子高度
        st.push(0);
        int sum = 0;
        for (int i = 1; i < height.size(); i++) {
            if (height[i] < height[st.top()]) {     // 情况一
                st.push(i);
            } if (height[i] == height[st.top()]) {  // 情况二
                st.pop(); // 其实这一句可以不加，效果是一样的，但处理相同的情况的思路却变了。
                st.push(i);
            } else {                                // 情况三
                while (!st.empty() && height[i] > height[st.top()]) { // 注意这里是while
                    int mid = st.top();
                    st.pop();
                    if (!st.empty()) {
                        int h = min(height[st.top()], height[i]) - height[mid];
                        int w = i - st.top() - 1; // 注意减一，只求中间宽度
                        sum += h * w;
                    }
                }
                st.push(i);
            }
        }
        return sum;
    }
};

精炼的写法，先放在这里。

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