Leetcode 42、接雨水

原创已于 2022-06-06 11:30:22 修改 · 954 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #职场和发展

于 2022-06-06 11:28:39 首次发布

Leetcode题解专栏收录该内容

47 篇文章

订阅专栏

本文详细介绍了LeetCode第42题“接雨水”的三种解决方案：双指针、动态规划和单调栈。通过比较左右最大高度来计算可接雨水的体积，提供代码实现并解释了每种方法的思路和优势。

Leetcode 42、接雨水

在这里插入图片描述

方法一、双指针

双指针
 思路和动态规划一样，不过这里是使用两个变量维护当前位置左边和右边的最大值，
 如果left位置的值小于right位置的值，就使用leftMax - left
 因为在动态规划里 求当前位置可以接的雨水的数目，
 也是使用左右最大值的最小值-当前位置的高度

 public int trap(int[] height) {
        int lrft = 0, right = height.length - 1;
        int leftMax = height[left], rightMax = height[right];
        int result = 0;

        while(left <= right) {
            leftMax = Math.max(leftMax, height[left]);
            rightMax = Math.max(rightMax, height[right]);
            /**
                这里left位置小于right的高度，说明leftMax<rightMax，因为如果左边的高度
                大于右边的高度，就移动right，让right--，相当于left一直处于大于right的leftMax的位置，
                直到右边的高度大于左边位置的高度的时候，就开始移动left指针

                每次都是把小的那一边的雨水量进行累加，因为可以接的雨水的数目取决于左右两边
                最大值中的较小值、
             */
            if(height[left] < height[right]) {
                result += leftMax - left;
                left++;
            }else{
                result += rightMax - right;
                rightM--;
            }
        }

        return result;
    }

方法二：动态规划

动态规划法：
使用left数组存储当前位置左边的最大值，right数组存储当前位置右边的最大值。
最后遍历两个数组，取最小值-height[i]，加到result里面，返回result。

public int trap(int[] height) {
    int len = height.length;
    int[] left = new int[len];
    int[] right = new int[len];
    
    left[0] = height[0];
    right[len - 1] = height[len - 1];

    for(int i = 1; i < len; i++) {
        left[i] = Math.max(left[i - 1], height[i]);
    }
    for(int i = len - 2; i >= 0; i--) {
        right[i] = Math.max(height[i], right[i + 1]);
    }

    int result = 0;
    for(int i = 0; i < len; i++) {
        result += Math.min(left[i], right[i]) - height[i];
    }

    return result;
}

方法三：单调栈

单调栈：接雨水一定是找到一个低洼的地方，也就是左边和右边的高度大于当前的高度，
    在遍历heights数组的时候，如果当前遍历的高度小于等于栈顶元素位置的高度，就直接入栈；
    如果当前遍历的高度大于栈顶元素位置的高度，因为对于栈来说，从栈顶到栈底是单调递增的，
    所以如果遍历的高度大于栈顶元素位置的高度，栈顶的下一个位置的元素也是大于等于栈顶元素的，
    
    以为栈里面存储的是下标，这个时候可以根据当前遍历的下标已经栈顶元素的下一个
    位置的下标确定宽度，栈顶元素在heights数组里面的高度是当前位置的高度，
    相乘就是可以接的雨水的量。
    
    累加到result里面，最后返回result。

 public int trap(int[] height) {
        int ans = 0;
        Deque<Integer> stack = new LinkedList<Integer>();
        int n = height.length;
        for (int i = 0; i < n; ++i) {
            /**
                这里的思路是当前位置大于栈顶元素，但是我们要去寻找的是一个低洼，所以要把栈顶元素pop，
                pop以后的栈顶元素和当前height[i]的元素一起形成一个低洼，那么刚才pop出去的位置
                可以接的雨水的数量是两边的最小值-pop出去的位置的值，然后乘上宽度i - left - 1。
             */
            while (!stack.isEmpty() && height[i] > height[stack.peek()]) {
                int top = stack.pop();
                if (stack.isEmpty()) {
                    break;
                }
                int left = stack.peek();
                int currWidth = i - left - 1;
                int currHeight = Math.min(height[left], height[i]) - height[top];
                ans += currWidth * currHeight;
            }
            stack.push(i);
        }
        return ans;
    }