【LeetCode-42】42. 接雨水

42. 接雨水

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

方法一：暴力法

/*
方法一：暴力法
时间复杂度 O(N^2)，空间复杂度 O(1)。但是很明显这种计算 r_max 和 l_max 的方式非常笨拙，一般的优化方法就是备忘录。
*/
class Solution {
    //考虑局部i，位置 i 能达到的水柱高度和其左边的最高柱子、右边的最高柱子有关，我们分别称这两个柱子高度为 max_left 和 max_right，位置 i 最大的水柱高度就是 min(max_left, max_right)
    public int trap(int[] height) {
        int ans = 0;
        int size = height.length;
        for (int i = 1; i < size - 1; i++) {
            int max_left = 0, max_right = 0;
            for (int j = i; j >= 0; j--) { //Search the left part for max bar size
                max_left = Math.max(max_left, height[j]);
            }
            for (int j = i; j < size; j++) { //Search the right part for max bar size
                max_right = Math.max(max_right, height[j]);
            }
            
            // 如果自己就是最高的话，
            // max_left == max_right == height[i]
            ans += Math.min(max_left, max_right) - height[i];
        }
        return ans;

    }
}

方法二：备忘录法

使用备忘录，避免重复计算

/*
方法二：备忘录法
最优：时间复杂度 O(N)
空间复杂度 O(n)
*/
class Solution {

    public int trap(int[] height) {
        if(height == null || height.length == 0) {
            return 0;
        }
        int ans = 0;
        int n = height.length;
        // 数组充当备忘录
        int l_max[] = new int[n];
        int r_max[] = new int[n];
        
        // 初始化 base case
        l_max[0] = height[0];
        r_max[n - 1] = height[n - 1];
        
        // 从左向右计算 l_max
        for (int j = 1; j < n; j++) {
            l_max[j] = Math.max(l_max[j - 1], height[j]);
        }
        // 从右向左计算 r_max
        for (int j = n - 2; j >= 0; j--) {
            r_max[j] = Math.max(r_max[j + 1], height[j]);
        }
        
        // 计算答案
        for (int i = 1; i < n - 1; i++) {
            ans += Math.min(l_max[i], r_max[i]) - height[i];
        }
        return ans;

    }
}

方法三：双指针解法

/*
方法三：双指针解法：不要用备忘录提前计算了，而是用双指针边走边算，节省下空间复杂度
最优：时间复杂度 O(N)
最优：空间复杂度 O(1)
*/
class Solution {

    public int trap(int[] height) {
        if(height == null || height.length == 0) {
            return 0;
        }
        int ans = 0;
        int n = height.length;
        
        //双指针
        int left = 0;
        int right = n - 1;

        // l_max 是 height[0..left] 中最高柱子的高度，
        // r_max 是 height[right..end] 的最高柱子的高度
        int l_max = height[0];
        int r_max = height[n - 1];
        
        while(left < right) {
            l_max = Math.max(l_max, height[left]);
            r_max = Math.max(r_max, height[right]);
            
            if(l_max < r_max) {
                ans += l_max - height[left];
                left++;
            } else {
                ans += r_max - height[right];
                right--;
            }
            
        }

        return ans;
    }
}