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

503.下一个更大元素II

503. 下一个更大元素 II - 力扣（LeetCode）

思路：单调栈

1. 单调递增栈；在遍历的过程中模拟走两边nums；

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        if(nums==null || nums.length<=1){
            return new int[]{-1};
        }
        int size = nums.length;
        int[] res = new int[size];
        Arrays.fill(res,-1);
        Stack<Integer> st = new Stack<>();
        for(int i=0;i<2*size;i++){
            while(!st.isEmpty()&&nums[i%size]>nums[st.peek()]){
                res[st.peek()]=nums[i%size];
                st.pop();
            }
            st.push(i%size);
        }
        return res;
    }
}

42. 接雨水

42. 接雨水 - 力扣（LeetCode）

思路1：双指针法

1. 按列计算，宽度为1，从头遍历（注意第一个柱子和最后一个柱子不接雨水），求出每一列雨水的高度（取决于该列左侧最高的柱子和右侧最高的柱子中更矮的那根柱子的高度，即 min(lHeight,rHeight)-height；

2. 将每一列雨水的体积相加，就是总雨水的体积；

class Solution {
    public int trap(int[] height) {
        int sum = 0;
        for(int i = 0;i<height.length;i++){
            if(i==0||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;
    }
}

思路2：动态规划

1. 把每一个位置的左边最高高度记录在一个数组上（maxLeft），右边最高高度记录在一个数组上（maxRight）；

2. 当前位置，左边的最高高度四前一个位置的左边最高高度和本高度的最大值；即从左往右遍历：maxLeft[i] = max(height[i],maxLeft[i-1])；从右向左遍历：maxRight[i] = max(height[i],maxRight[i+1])；

3. 求和；

class Solution {
    public int trap(int[] height) {
        int len = height.length;
        if(len<=2) return 0;
        int[] maxLeft = new int[len];
        int[] maxRight = new int[len];
        maxLeft[0] = height[0];
        for(int i=1;i<len;i++) maxLeft[i] = Math.max(height[i],maxLeft[i-1]);
        maxRight[len-1] = height[len-1];
        for(int i=len-2;i>=0;i--) maxRight[i] = Math.max(height[i],maxRight[i+1]);
        int sum = 0;
        for(int i=1;i<len;i++){
            int count = Math.min(maxLeft[i],maxRight[i])-height[i];
            if(count>0) sum += count;
        }
        return sum;
    }
}

思路3：单调栈

1. 单调栈按照行方向来计算雨水，如下所示：

2. 单调栈内元素的顺序：从栈头（元素从栈头弹出）到栈底的顺序应该是从小到大的顺序。当添加的柱子高度大于栈头元素时，就说明出现了凹槽；栈头元素就是凹槽底部的柱子，栈头第二个元素就是凹槽左边的柱子，而添加的元素就是凹槽右边的柱子。

3. 当遇到相同高度的柱子时：更新栈内下标，将栈内元素（旧下标）弹出，将新元素（新下标）加入栈。

4. 栈中元素的类型：int类型即可，表示下标；利用height[stack.peek()]得知弹出下标对应的高度。

5. 单调栈处理逻辑：先将下标为0的柱子加入栈中，然后开始从下标1遍历所有的柱子。当所遍历的元素（柱子）的高度小于栈顶元素的高度时，就将这个元素加入栈中。若所遍历的元素高度等于栈顶元素的高度，就更新栈顶元素。若当前遍历的元素高度大于栈顶元素的高度，取栈顶元素，将栈顶元素弹出，记为mid，对应的高度为height[mid]，当前遍历的元素 i 就是凹槽右边的位置，下标为 i ，对应的高度为height[i]，雨水高度h为 min(height[st.peek()],height[i])-height[mid]；雨水宽度w为凹槽右边的下标-凹槽左边的下标-1，即 i-st.peek()-1；雨水体积为 h*w；

class Solution {
    public int trap(int[] height) {
        int size = height.length;
        if(size<=2) return 0;
        Stack<Integer> stack = new Stack<>();
        stack.push(0);
        int sum = 0;
        for(int index = 1;index<size;index++){
            int stackTop = stack.peek();
            if(height[index]<height[stackTop]){
                stack.push(index);
            }else if(height[index]==height[stackTop]){
                stack.pop();
                stack.push(index);
            }else{
                int heightAtIdx = height[index];
                while(!stack.isEmpty()&& heightAtIdx>height[stackTop]){
                    int mid = stack.pop();
                    if(!stack.isEmpty()){
                        int left = stack.peek();
                        int h = Math.min(height[left],height[index])-height[mid];
                        int w = index-left-1;
                        int hold = h*w;
                        if(hold>0) sum+=hold;
                        stackTop = stack.peek();
                    }
                }
                stack.push(index);
            }
        }
        return sum;
    }
}