【LeetCode刷题笔记Java】42.接雨水

• 题目：给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例：输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。

• 暴力方法

    public int trap(int[] height){
        int result = 0;
        for (int i = 0; i < height.length; i++){
            int leftMax = 0;
            int rightMax = 0;
            for (int k = i; k >= 0; k--){
                leftMax = Math.max(height[k], leftMax);
            }
            for (int k = i; k < height.length; k++){
                rightMax = Math.max(height[k], rightMax);
            }
            if (leftMax > height[i] && rightMax > height[i]) {
                    result += Math.min(leftMax, rightMax) - height[i];
            }
        }
        return result;
    }

• 动态规划

• 动态规划，在暴力法的基础上用两个dp数组保存左右最大值
• 时间复杂度：O（N），空间复杂度：O（N）

    public int trap(int[] height){
        int result = 0;
        int[] leftMaxDp = new int[height.length];
        int[] rightMaxDp = new int[height.length];
//        第一次循环找出每个位置的左侧最大值记录下来
        for (int i = 1; i < height.length; i++){
            leftMaxDp[i] = Math.max(height[i - 1], leftMaxDp[i - 1]);
        }
//        第二次同上
        for (int i = height.length - 2; i >= 0; i--){
            rightMaxDp[i] = Math.max(height[i + 1], rightMaxDp[i + 1]);
        }

        for (int i = 0; i < height.length; i++){
            int minValue = Math.min(leftMaxDp[i], rightMaxDp[i]);
            if (minValue > height[i])
                result += minValue - height[i];
        }
        return result;
    }

• 单调栈
  单调栈方法，维护一个从栈顶到栈底递增的单调栈，借助它判断雨水

    public int trap(int[] height){
        int res = 0;
        LinkedList<Integer> stack = new LinkedList<>();
        int current = 0;
        while (current < height.length){
//            做新元素入栈判断，如果栈不为空且栈顶元素小于新元素就不断弹出栈顶元素，反之新元素入栈
            while (!stack.isEmpty() && height[current] > height[stack.peek()]){
                int h = height[stack.pop()];
                if (stack.isEmpty())
                    break;
//                计算当前元素与上上个元素位置的距离，注意这里中间隔着若干元素
                int distance = current - stack.peek() - 1;
                int min = Math.min(height[current], height[stack.peek()]);
                res += distance * (min - h);
            }
            stack.push(current);
            current++;
        }
        return res;
    }