42-接雨水

题目

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

示例 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 个单位的雨水（蓝色部分表示雨水）。
示例 2：

输入：height = [4,2,0,3,2,5]
输出：9

题解一 按列求

class Solution {
    public int trap(int[] height) {
        //i表示储水区，左右两侧不可能储水
        int ans=0;
        for(int i=1;i<height.length-1;i++){
            //找出左侧最高点
            int leftMax=0;
            for(int j=i-1;j>=0;j--){
                if(height[j]>leftMax){
                    leftMax=height[j];
                }
            }
            //找出右侧最高点
            int rightMax=0;
            for(int j=i+1;j<height.length;j++){
                if(height[j]>rightMax){
                    rightMax=height[j];
                }
            }
            int minHeight=Math.min(leftMax,rightMax);
            if(height[i]<minHeight){
                ans+=minHeight-height[i];
            }
        }
        return ans;
    }
}

思路：

1. 找出左边的最高列和右边的最高列，将当前列与两端较小的最高列进行对比，只有当前列比较小列低时才能存住水。

题解二 动态规划

class Solution {
    public int trap(int[] height) {
        int[] leftMax=new int[height.length];//因为对应的是i个储水的height，所以不需要length+1
        int[] rightMax=new int[height.length];
        int ans=0;
        for(int i=1;i<height.length;i++){
            leftMax[i]=Math.max(leftMax[i-1],height[i-1]);
        }
        for(int i=height.length-2;i>=0;i--){
      	 rightMax[i]=Math.max(rightMax[i+1],height[i+1]);
        }
        for(int i=1;i<height.length-1;i++){
            int minHeight=Math.min(leftMax[i],rightMax[i]);
            if(height[i]<minHeight){
                ans+=minHeight-height[i];
            }
        }
        return ans;
    }
}

思路：

1. 在求左右最高的墙时可以用动态规划，求出左边的墙和左边之前最高的墙哪个更高，这样就不用每次都求一次左右最高的墙了。
2. 相当于用动态规划数组储存了每个i处的左右最高点。

题解三 双指针

class Solution {
    public int trap(int[] height) {
        int sum=0;
        int leftMax=0;
        int rightMax=0;
        int left=1;//左右指针 指示height？
        int right=height.length-2;
        for(int i=1;i<height.length-1;i++){
            if(height[left-1]<height[right+1]){
                leftMax=Math.max(leftMax,height[left-1]);
                int min=leftMax;
                if(height[left]<min){//left?两个指针，i只是用来循环的
                    sum+=min-height[left];
                }
                left++;
            }else{
                rightMax=Math.max(rightMax,height[right+1]);
                int min=rightMax;
                if(height[right]<rightMax){
                    sum+=rightMax-height[right];
                }
                right--;//注意指针移动方向--
            }
        }
        return sum;
    }
}

思路：

1. 定理一：在某个位置i处，它能存的水，取决于它左右两边的最大值中较小的一个。

定理二：当我们从左往右处理到left下标时，左边的最大值left_max对它而言是可信的，但right_max对它而言是不可信的。（见下图，由于中间状况未知，对于left下标而言，right_max未必就是它右边最大的值）

定理三：当我们从右往左处理到right下标时，右边的最大值right_max对它而言是可信的，但left_max对它而言是不可信的。

                                   right_max
 left_max                             __
   __                                |  |
  |  |__   __??????????????????????  |  |
__|     |__|                       __|  |__
        left                      right

对于位置left而言，它左边最大值一定是left_max，右边最大值“大于等于”right_max，这时候，如果left_max<right_max成立，那么它就知道自己能存多少水了。无论右边将来会不会出现更大的right_max，都不影响这个结果。 所以当left_max<right_max时，我们就希望去处理left下标，反之，我们希望去处理right下标。

题解四 栈

class Solution {
    public int trap(int[] height) {
        int sum=0;
        Stack<Integer> stack=new Stack<>();
        int current=0;
        while(current<height.length){
            while(!stack.empty()&&height[current]>height[stack.peek()]){
                int h=height[stack.peek()];
                stack.pop();//取出栈顶的元素,栈顶元素的高度已经保存了，就可以出栈了！因为求distance不需要这个了
                if(stack.empty()){//栈空就说明目前没有比current更小的高度了，就不可能有积水了
                    break;
                }
                int distance=current-stack.peek()-1;//看当前的指针和栈顶元素之间的距离
                int min=Math.min(height[current],height[stack.peek()]);
                sum+=(min-h)*distance;//注意长*宽！
            }
            stack.push(current);//如果current元素较小的话直接入栈
            current++;
        }
        return sum;
    }
}

思路：

1. 遇到小于栈顶高度的就入栈，大于栈顶高度的就将栈顶元素出栈，并计算之间的差值。