代码随想录算法训练营 day59 | 503.下一个更大元素II、42. 接雨水

代码随想录

503.下一个更大元素II

思路

模拟遍历两遍数组，然后用单调栈 从栈头到栈底递增的顺序来写。
当当前元素大于栈顶元素，就弹出栈顶元素。每次必然将当前元素的索引加入到栈

代码

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        Stack<Integer> s = new Stack<Integer>();
        int len = nums.length;
        int res[] = new int[len];
        Arrays.fill(res,-1);
        s.push(0);
        for(int i = 1;i<len*2;i++){
            while(!s.isEmpty() && nums[s.peek()]<nums[i%len]){

                int t = s.pop(); 
                res[t] = nums[i%len];

            }
            s.push(i%len);
        }
        return res;

    }
}

42. 接雨水

思路

思路：有三种方法
暴力解法
双指针法+动态规划法
单调栈法

暴力解法：
可以按照行 or 按照列计算，实际上也是用双指针法
按照列计算，宽度是1，只需要求出列的可接雨水的高度
某一列的可接雨水的高度= min(lHeight, rHeight) - height。
遍历所有的列，在for循环中秋左边的最高高度和右边的最高高度。
代码：
class Solution {
public int trap(int[] height) {
int sum = 0;
for (int i = 0; i < height.length; i++) {
// 第一个柱子和最后一个柱子不接雨水
if (i0 || i height.length - 1) continue;

        int rHeight = height[i]; // 记录右边柱子的最高高度
        int lHeight = height[i]; // 记录左边柱子的最高高度
        for (int r = i+1; r < height.length; r++) {
            if (height[r] > rHeight) rHeight = height[r];
        }
        for (int l = i-1; l >= 0; l--) {
            if(height[l] > lHeight) lHeight = height[l];
        }
        int h = Math.min(lHeight, rHeight) - height[i];
        if (h > 0) sum += h;
    }
    return sum;

}

}

双指针法：
先分别用一个数组记录好每个柱子左边的最大高度 和右边的最大高度，然后用公式
// 求和
int sum = 0;
for (int i = 0; i < size; i++) {
int count = min(maxLeft[i], maxRight[i]) - height[i];
if (count > 0) sum += count;
}

单调栈法：
因为接雨水需要找到右边最大元素和左边最大元素，可以用单调栈
是按照行的方向计算雨水，计算所有宽度的累加
单调栈从栈头到栈底是从小到大的顺序。
因为一旦发现添加的柱子高度大于栈头元素了，此时就出现凹槽了，栈头元素就是凹槽底部的柱子，栈头第二个元素就是凹槽左边的柱子，而添加的元素就是凹槽右边的柱子。

遇到相同的元素，更新栈内下标，就是将栈里元素（旧下标）弹出，将新元素（新下标）加入栈中。

例如 5 5 1 3 这种情况。如果添加第二个5的时候就应该将第一个5的下标弹出，把第二个5添加到栈中。

因为我们要求宽度的时候 如果遇到相同高度的柱子，需要使用最右边的柱子来计算宽度。

单调栈中存放的仍然是数组下标。
雨水的体积是 高x宽
高度的计算方式是int h = min(height[st.top()], height[i]) - height[mid];
宽度的计算方式是凹槽右边的下标 - 凹槽左边的下标 - 1（因为只求中间宽度），代码为：int w = i - st.top() - 1 ;

分三种情况
当当前元素小于栈顶，直接压入
当当前元素等于栈顶，先弹出再压入
当当前元素大于栈顶，每次只弹出凹槽的部分，然后计算凹槽部分雨水的体积。直到没有比栈顶元素更大，然后压入。

代码

class Solution {
    public int trap(int[] height) {
        int sum = 0;
        Stack<Integer> s = new Stack<>();
        s.push(0);
        for(int i =1;i<height.length;i++){
            if(height[i]<height[s.peek()]){
                s.push(i);
            }else if(height[i]==height[s.peek()]){
                s.pop();
                s.push(i);
            }else{

                while(!s.isEmpty() && height[i]>height[s.peek()]){
                    int mid = s.pop();
                    if(!s.isEmpty()){
                        int h = Math.min(height[s.peek()],height[i])-height[mid];
                        int w = i-s.peek()-1;
                        sum += h*w;
                    }
                }
                s.push(i);
            }
        }

        return sum;

    }
}