牛客-NC128-接雨水

方法一：暴力法

思路：对于数组每一个元素，我们需要找到它左边的最高柱子以及它右边的最高柱子，而盛水的多少取决于左右柱子的较小值减去当前元素柱子高度。看代码：

import java.util.*;


public class Solution {
    /**
     * max water
     * @param arr int整型一维数组 the array
     * @return long长整型
     */
    public long maxWater (int[] arr) {
        // write code here
        long ret = 0;
        int len = arr.length;
        // 特判
        if (len < 3) return ret;
        // 暴力法
        for (int i = 1; i < len - 1; i++) {
            int max_left = 0, max_right = 0;
            for (int j = i; j >= 0; j--) { // 找左边最高的柱子
                max_left = Math.max(max_left, arr[j]);
            }
            for (int j = i; j < len; j++) { // 找右边最高的柱子
                max_right = Math.max(max_right, arr[j]);
            }
            ret += Math.min(max_left, max_right) - arr[i];
        }
        return ret;
    }
}

时间复杂度： O(N²)，N表示数组arr的长度，因为对于每一个元素我们都需要向左向右扫描。
空间复杂度： O(1)，额外空间不包含返回所需的常数ret。

方法二：动态规划法

思路：方法一在求解左右最高柱子时包含了不少重复计算，我们做如下考虑：能否通过一次遍历得到数组每一个元素的左边最高柱子值，再通过一次遍历得到数组每一个元素的右边最高柱子值。最后通过一次遍历从左到右，依次计算当前数组元素下，能够盛水的最大值。看代码：

import java.util.*;


public class Solution {
    /**
     * max water
     * @param arr int整型一维数组 the array
     * @return long长整型
     */
    public long maxWater (int[] arr) {
        // write code here
        long ret = 0;
        int len = arr.length;
        // 特判
        if (len < 3) return ret;
        int[] left_max_arr = new int[len];
        int[] right_max_arr = new int[len];
        left_max_arr[0] = arr[0];
        right_max_arr[len - 1] = arr[len - 1];
        for (int i = 1; i < len; i++) {
            left_max_arr[i] = Math.max(left_max_arr[i - 1], arr[i]);
        }
        for (int i = len - 2; i >= 0; i--) {
            right_max_arr[i] = Math.max(right_max_arr[i + 1], arr[i]);
        }
        for (int i = 0; i < len; i++) {
            ret += Math.min(left_max_arr[i], right_max_arr[i]) - arr[i];
        }
        return ret;
    }
}

时间复杂度： O(N)，N表示数组arr的长度，我们需要遍历三遍数组，总时间复杂度为O(N)。
空间复杂度： O(N)，我们需要两个数组left_max_arr和right_max_arr来存当前数组元素的左边最高柱子和右边最高柱子。

方法三：单调栈法

思路：方法二可以进一步优化，不需要额外的数组来存最高柱子，而是用栈来跟踪最长的柱子。具体而言，我们在遍历数组时维护一个栈。如果当前的柱子小于或等于栈顶的柱子，我们将该柱子的索引入栈，意思就是当前的柱子被栈里面的前一个柱子界定（因为前一个柱子肯定大于等于当前的柱子）。如果我们发现一根柱子高于栈顶柱子，我们可以确定栈顶的柱子被当前柱子和栈的前一个柱子界定，因为，我们可以弹出栈顶元素并计算盛水容量累加到ret中。看代码：

import java.util.*;


public class Solution {
    /**
     * max water
     * @param arr int整型一维数组 the array
     * @return long长整型
     */
    public long maxWater (int[] arr) {
        // write code here
        long ret = 0;
        int len = arr.length;
        // 特判
        if (len < 3) return ret;
        // 单调递减栈法
        int cur = 0;
        Deque<Integer> stack = new LinkedList<>();
        while (cur < arr.length) {
            while (!stack.isEmpty() && arr[cur] > arr[stack.peek()]) {
                int top = stack.pop();
                if (stack.isEmpty()) break;
                long distance = cur - stack.peek() - 1; // 长
                long bound_height = Math.min(arr[cur], arr[stack.peek()]) - arr[top]; // 宽
                ret += distance * bound_height;
            }
            stack.push(cur++);
        }
        return ret;
    }
}

时间复杂度： O(N)，N表示数组arr的长度，每个数组元素最多被访问两次（栈入和栈出），并且栈入和栈出都是O(1)。
空间复杂度： O(N)，最坏情况下数组元素呈阶梯型或平坦型，此时需要全部入栈。
注：这里分享一个讲单调栈的链接，单调栈入门。

方法四：双指针法（最优解）

思路：实在没看懂官方题解（真是一个笨蛋啊！），这里讲一下评论区第一的题解，我们先明确几个变量的意思：

int left = 0; // 从左往右处理的当前数组下标
int right = arr.length - 1; // 从右往左处理的当前数组下标
long left_max = 0; // 左边的最大值，它是从右往左遍历得到的
long right_max = 0; // 右边的最大值，它是从右往左遍历得到的

定理一：在某个位置i处，它能存的水，取决于它左右两边的最大值中较小的一个。
定理二：当我们从左往右处理到left下标时，左边的最大值left_max对它而言是可信的。但right_max对它而言是不可信的。（见下图，由于中间状况未知，对于left下标而言，right_max未必就是它右边最大的值）
定理三：当我们从右往左处理到right下标时，右边的最大值right_max对它而言是可信的，但left_max对它而言是不可信的。

做以下考虑：对于位置left而言，它左边最大值一定是left_max，右边最大值大于等于right_max（为什么呢？因为right_max就是当前右边的最大值，可能还会有更大的right_max出现，但绝对不可能出现更小的right_max了），这个时候，如果left_max < right_max成立，那么它就知道自己能存多少水了。无论右边将来会不会出现更大的right_max，都不影响这个结果（定理一）。所以当left_max < right_max时，我们就希望去处理left下标，反之，我们希望去处理right下标。看代码：

import java.util.*;


public class Solution {
    /**
     * max water
     * @param arr int整型一维数组 the array
     * @return long长整型
     */
    public long maxWater (int[] arr) {
        // write code here
        long ret = 0;
        int len = arr.length;
        // 特判
        if (len < 3) return ret;
        // 双指针法
        int left = 0, right = arr.length - 1;
        long left_max = 0, right_max = 0;
        while (left <= right) {
            if (left_max < right_max) {
                ret += Math.max(0, left_max-arr[left]);
                left_max = Math.max(left_max, arr[left]);
                left += 1;
            } else {
                ret += Math.max(0, right_max-arr[right]);
                right_max = Math.max(right_max, arr[right]);
                right -= 1;
            }
        }
        return ret;
    }
}

时间复杂度： O(N)，N表示数组arr的长度。
空间复杂度： O(1)，left、right、left_max、right_max只需要常数的空间。
总结：对于hard题目先从暴力解法入手，再一步一步进行优化。但这道题自己连暴力解都没想到，始终想着从中间最高柱子入手，困在里面了。其实这道题最核心的还是在于当前柱子盛水的多少取决于左右柱子的较小值减去当前元素柱子高度。这也是动规的核心。再次复习单调栈的写法，这次好像真的明白了单调栈。双指针的写法还是有些不理解，分享给大家一个链接吧，LC官方题解。