（动态规划、栈、双指针）难！Leetcode算法题42. 接雨水

共有3种方法

1. 暴力法

class Solution {
    /*
   向两边寻找，直到找到比该处高的两点，两点中最小的值减去
   该点的值即是该点累计收集到的雨量
    */
    public int trap(int[] height) {
        int trap = 0;

        for(int i = 0; i < height.length; i++){
            int max_left = height[i], max_right = height[i];

            for(int j = i - 1; j >= 0; j--){
                max_left = Math.max(height[j], max_left);
            }
            for(int j = i + 1; j < height.length; j++){
                max_right = Math.max(height[j], max_right);
            }

            trap += Math.min(max_left, max_right) - height[i];
        }

        return trap;
    }
}

2. 动态编程（动态规划）

/*
向两边寻找，直到找到比该处高的两点，两点中最小的值减去
该点的值即是该点累计收集到的雨量
 */
public static int trap(int[] height) {
    int len = height.length;
    if(len == 0) return 0;

    int ans = 0;
    //用两个数组储存每个点的左边最大值和右边最大值
    int[] left_max = new int[len];
    int[] right_max = new int[len];
    left_max[0] = height[0];
    right_max[len - 1] = height[len - 1];

    for(int i = 1; i < len; i++){
        left_max[i] = Math.max(height[i], left_max[i - 1]);
    }

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

    for(int i = 1; i < len - 1; i++){
        ans += Math.min(left_max[i], right_max[i]) - height[i];
    }

    return ans;
}

3. 栈方法（难！）

//栈方法
public static int trap(int[] height) {
    int len = height.length;
    if(len == 0) return 0;

    int ans = 0;
    //用栈储存元素位置
    Deque<Integer> stack = new LinkedList<>();

    /*
    current为当前元素的位置

    如果当前位置的高度大于栈顶元素位置的高度，则栈顶元素所处位置可能
    有积水，弹出该元素后，Math.min(height[stack.peekLast()], height[current])
        //height[stack.peekLast()]为新的栈顶元素位置的高度
    min_h即为容器的高度，ans += (min_h - h) * (current - stack.peekLast() - 1)

    积水量是一层一层的叠加的，用while循环不断地寻找左墙以及左边可能有积水的位置，
    直到没有左墙或者左墙的高度高于当前位置的高度，退出循环，将该位置压入栈
    */
    for(int current = 0; current < len; current++){
        while (!stack.isEmpty() && height[current] > height[stack.peekLast()]){
            int h = height[stack.pollLast()];

            if(stack.isEmpty()){
                break;
            }

            int min_h = Math.min(height[stack.peekLast()], height[current]);
            ans += (min_h - h) * (current - stack.peekLast() - 1);
        }
        stack.addLast(current);
    }

    return ans;
}

4. 双指针方法（难！）

//双指针方法
public static int trap(int[] height) {
    int len = height.length;
    if(len == 0) return 0;

    int ans = 0;
    int left = 0, right = len - 1;
    int left_max = 0;
    int right_max = 0;

    /*
    双指针，从两边向中间寻找，容器的接水量由最短的那一边决定，
    两个指针会不断向最高的那一边靠拢。
    */
    while (left <= right){
        if(left_max < right_max){
            if(left_max <= height[left]){
                left_max = height[left];
            }
            else {
                ans += left_max - height[left];
            }
            ++left;
        }
        else {
            if(right_max <= height[right]){
                right_max = height[right];
            }
            else {
                ans += right_max - height[right];
            }
            --right;
        }
    }

    return ans;
}