42.Trapping Rain Water---dp,stack,两指针

题目链接：https://leetcode.com/problems/trapping-rain-water/description/

题目大意：与84题做比较，在直方图中计算其蓄水能力。例子如下：

法一（借鉴）：暴力，还是很难想到的，需要推理数学功底。因为这里暴力的前提条件是：计算每个点的蓄水能力，相当于求解，min(每个点左边的最大高度，每个点右边的最大高度）-当前值。也就是这里，把一整个蓄水池的分解成一个点一个点的蓄水能力。代码如下（耗时150ms）：

    public int trap(int[] height) {
        int res = 0;
        for(int i = 0; i < height.length; i++) {
            int left = height[i], right = height[i];
            //找左边最大高度
            for(int j = i - 1; j >= 0; j--) {
                left = Math.max(left, height[j]);
            }
            //找右边最大高度
            for(int j = i + 1; j < height.length; j++) {
                right = Math.max(right, height[j]);
            }
            //计算蓄水
            res += Math.min(left, right) - height[i];
        }
        return res;
    }

法二（借鉴）：一维dp，思想与上面暴力相同，都是取左右两边高度的较小者然后与当前值比较，如果大，则可以蓄水。代码如下（耗时22ms）：

    public int trap(int[] height) {
        int dp[] = new int[height.length];
        int ma = 0, res = 0;
        //记录i值左边的最大高度
        for(int i = 0; i < height.length; i++) {
            dp[i] = ma;
            //更新左边最大高度
            ma = Math.max(ma, height[i]);
        }
        //更新计算i值右边的最大高度
        ma = 0;
        for(int i = height.length - 1; i >= 0; i--) {
            //在左边和右边最大高度中取较小者
            dp[i] = Math.min(dp[i], ma);
            //更新右边
            ma = Math.max(ma, height[i]);
            //如果两边高度比当前高度高，则表示可以蓄水
            if(dp[i] > height[i]) {
                res += dp[i] - height[i];
            }
        }
        return res;
    }

法三（借鉴）：stack，与84题stack做法比较，此题在压栈的时候是降序高度压栈，当当前高度>s.peek()时，可以蓄水，栈顶第一个元素为坑最低高度，栈顶第二个元素为左边界，当前高度为右边界，坑深为min(左高度，右高度)-坑最低高度。代码如下（耗时30ms）：

    //入栈递减高度，当当前高度>s.peek()时，可以蓄水，栈顶第一个元素为坑最低高度，栈顶第二个元素为左边界，当前高度为右边界，坑深为min(左高度，右高度)-坑最低高度
    public int trap(int[] height) {
        Stack<Integer> s = new Stack<Integer>();
        int res = 0;
        for(int i = 0; i < height.length; i++) {
            //循环查找在当前高度下，是否可以蓄水
            while(!s.isEmpty() && height[i] > height[s.peek()]) {
                int cur = s.pop();
                //如果栈空，说明没有左边界，没法蓄水，所以直接break
                if(s.isEmpty()) {
                    break;
                }
                //计算蓄水，此时不再是按照前面的方法，分点计算竖状蓄水能力，而是按照整块的蓄水能力计算的，也就是普通思维的按照蓄水池的长*宽来计算的
                res += (i - s.peek() - 1) * (Math.min(height[s.peek()], height[i]) - height[cur]);
            }
            //如果比栈顶高度小，压栈
            s.push(i);
        }
        return res;
    }

 法四（借鉴）：两个指针移动，比较左指针指向的高度和右指针指向的高度，记录较小者，如果左指针指向的较小，则从左往右遍历，如果右指针指向的较小，则从右往左遍历，如果遍历到的当前值比较小者小，则表示可以蓄水：较小者-当前值。代码如下（22ms）：

    //定义两个指针，左指针与右指针的值进行比较，记录较小者，如果左指针较小，则从左往右遍历，如果右指针较小，则从右往左遍历，如果遍历到的值比较小者小，则表示可以蓄水：较小者-当前值
    public int trap(int[] height) {
        int left = 0, right = height.length - 1, mi = 0, res = 0;
        while(left < right) {
            //如果左指针较小，从左往右遍历
            if(height[left] < height[right]) {
                mi = height[left++];
                while(left < right && height[left] < mi) {
                    res += mi - height[left++];
                }
            }
            //如果右指针较小，从右往左遍历
            else {
                mi = height[right--];
                while(left < right && height[right] < mi) {
                    res += mi - height[right--];
                }
            }
        }
        return res;
    }