L42接雨水

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

上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。
感谢 Marcos 贡献此图。

示例:

输入: [0,1,0,2,1,0,1,3,2,1,2,1] 输出: 6

1.一行一行的计算

class Solution {
    public int trap(int[] height) {
        int sum  = 0;
        int max = getMax(height);
        for(int i = 1; i <= max; i++){
            //一行一行的处理
            int tmp = 0;
            boolean flag = false;
            for(int j = 0; j < height.length; j++){
                if(flag && height[j] <i){//只有小于i的时候才有空位置接水
                    tmp++;
                }
                if(height[j] >= i){//满足情况时，说明水可以被封起来，才可以结算
                    sum += tmp;
                    tmp = 0;
                    flag = true;//即只有开头有>= i的时候，才能更新tmp
                }
            }
        }
        return sum;
    }
    int getMax(int[] height){
        int max = 0;
        for(int i = 0; i < height.length; i++){
            max = Math.max(max, height[i]);
        }
        return max;
    }
}

2.动态规划，一步步精简

2.1一列一列，分别比较两边的最大值

class Solution {
    public int trap(int[] height) {
        int len = height.length;
        int ans = 0;
        for(int i = 1; i < len - 1; i++){//必然不会在两端
            int left = 0, right = 0;
            for(int j = 0; j < i; j++){//找最大值,要考虑两端
                left = Math.max(left, height[j]);
            }
            for(int j = i + 1; j < len; j++){
                right = Math.max(right, height[j]);
            }
            int min = Math.min(left, right);
            if(height[i] < min){
                ans  += (min - height[i]);
            }
        }
        return ans;
    }
}

2.2利用数组存储起来
但是空间复杂度过大

class Solution {
    public int trap(int[] height) {
        int len = height.length;
        int ans = 0;
        int left[] = new int[len];
        int right[] = new int[len];
        for(int i = 1; i < len; i++){//从1开始
            left[i] = Math.max(height[i - 1], left[i - 1]);
        }
        for(int i = len - 2; i >= 0; i--){//len - 2开始，不然会越界
            right[i] = Math.max(height[i+ 1], right[i + 1]);
        }
        for(int i = 1; i < len - 1; i++){//必然不会在两端
            
            int min = Math.min(left[i], right[i]);
            if(height[i] < min){
                ans  += (min - height[i]);
            }
        }
        return ans;
    }
}

2.3缩小空间复杂度
尝试压缩数组，因为每一个元素就用了一次，看是否能够用单一变量来替代
先将left数组进行压缩，但是right是无法压缩的

class Solution {
    public int trap(int[] height) {
        int len = height.length;
        int ans = 0;
        
        int right[] = new int[len];
        
        for(int i = len - 2; i >= 0; i--){//len - 2开始，不然会越界
            right[i] = Math.max(height[i+ 1], right[i + 1]);
        }
        int left = 0;
        for(int i = 1; i < len - 1; i++){//必然不会在两端
            left = Math.max(left, height[i - 1]);//减少空间复杂度
            int min = Math.min(left, right[i]);
            if(height[i] < min){
                ans  += (min - height[i]);
            }
        }
        return ans;
    }
}

运用双指针的方法

就是一个意思：当前height[left - 1] < height[right + 1],那么代表两边的最大值max_left 一定小于max_right，因为这个结果是不断继承过来的，这样可以只用两个变量便可以判断，不再使用数组了。

class Solution {
    public int trap(int[] height) {
        int len = height.length;
        int ans = 0;
        int left = 1;//指针,表示当前需要计算的位置,而不是范围
        int right = len -2;
        int max_left = 0, max_right = 0;//记录两端最值
        for(int i = 1; i < len - 1; i++){//必然不会在两端,这里表示计算的次数

            if(height[left - 1] < height[right + 1]){//从左向右，谁小以谁为准
                max_left = Math.max(max_left, height[left - 1]);
                if(height[left] < max_left){//这里不能写成i,i只是计数
                    ans += max_left -  height[left];
                }
                left++;//继续移动
            }else{
                max_right = Math.max(max_right, height[right + 1]);
                if(height[right] < max_right){
                    ans += max_right - height[right];
                }
                right--;
            }
        }
        return ans;
    }
}

单调栈的应用：

注意思路与以往不太一样，如果想有存水，若选择单调增栈，遇到当前小于栈顶时出栈，其实是不能存水的，
存水的要求：要求先减少后增加，这样才能存水
对应为单调减栈，当遇到当前值大于栈顶时出栈，这个时候（当前值-栈顶下的值）恰好可以形成高度差，栈顶恰好就是最低点，这个时候能够存水，这个时候要计算当前与栈顶下面的元素所存的水，然后栈顶元素出栈，再计算与新的栈顶元素所包围形成的水，累加即可得


current与栈顶对应的恰好就是左右两边
注意要乘以宽度，累加和的计算方式是一层层计算累加和的，不会出现重复相加的情况

class Solution {
    public int trap(int[] height) {
        int sum = 0, len = height.length;

        ArrayDeque<Integer> st = new ArrayDeque<>();
        //栈中存放数组的下标，方便计算两堵墙的距离

        for(int i = 0; i < len; i++){
            //相同的模板，当前栈为递减栈
            while(!st.isEmpty() && height[i] > height[st.peek()]){
                //若当前值大于栈顶
                int h = height[st.pop()];//获取当前最凹处的高度
                if(st.isEmpty()) break;//若此时为空，中断，继续for循环
                //因为此时并没有找到对应的max_left，所以可直接退出

                //此时的栈顶恰好是max_left对应的墙
                int width = i - st.peek() - 1;//两堵墙的距离
                int min = Math.min(height[st.peek()], height[i]);
                //相当于Min ( max _ left ，max _ right)

                sum += width * (min - h);//计算该部分的积水量
            }
            st.push(i);
        }
        return sum;
    }
}