Leetcode1-100: 42. Trapping Rain Water

问题描述

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.

Example:

	Input: [0,1,0,2,1,0,1,3,2,1,2,1]
	Output: 6

题目要求： 输入一个整形数组表示一个水池的高度，输出里面能够存储的最大储水量（说不大清楚，直接看图即可，即输入的是黑色的部分，求出蓝色部分的格子数量）。

解题思路

1. 统计横向的格子数量

首先得出所有黑色格子的最大值，然后从0开始到最高，统计每行储存的水量。例如图中的例子，首先第一行能够得到2储水量，然后第二行能够得到4储水量……最后第三行没有水。所以最后结果得到6

2. 统计每一列的储水量

从左到右遍历水池，对于每一列，找出它左边和右边的最大值max-left及max-right，然后类似于水桶短板原理，只要两边最大值中的较小者能够大于当前列的值，这一列就可以储水，能够储水的量是min(max-left, max-right) - nums[i]，如果这个值小于0则无法储水。

3. 利用动态规划来改进思路2

利用两个数组分别统计每个位置的max-left和max-right，遍历的时候直接用数组中的数据即可。这样能够把时间复杂度缩小到O(n)

代码实现

implement 1

public int trap(int[] height) {
        int sum = 0;
        int max = getMax(height);//找到最大的高度，以便遍历。
        for (int i = 1; i <= max; i++) {
            boolean isStart = false; //标记是否开始更新 temp
            int temp_sum = 0;
            for (int j = 0; j < height.length; j++) {
                if (isStart && height[j] < i) {
                    temp_sum++;
                }
                if (height[j] >= i) {
                    sum = sum + temp_sum;
                    temp_sum = 0;
                    isStart = true;
                }
            }
        }
        return sum;
    }

    private int getMax(int[] height) {
        int max = 0;
        for (int i = 0; i < height.length; i++) {
            if (height[i] > max) {
                max = height[i];
            }
        }
        return max;
    }

数据量很大，大概有个一两万的长度，直接不通过了，得优化。
复杂度分析：
时间复杂度： O(nL)，其中L是最长的那个数
空间复杂度： O(1)

implement 2

public int trap(int[] height) {
        int sum = 0;
        for(int i = 1; i < height.length - 1; i++) {
            int max_left = 0;
            for(int j = i - 1; j >= 0; j--) {
                if (height[j] > max_left) {
                    max_left = height[j];
                }
            }
            int max_right = 0;
            for(int j = i + 1; j < height.length; j++) {
                if (height[j] > max_right) {
                    max_right = height[j];
                }
            }
            int min = Math.min(max_left, max_right);
            if (min > height[i]) {
                sum = sum + (min - height[i]);
            }
        }
        return sum;
    }

复杂度分析：
时间复杂度： O(n²)
空间复杂度： O(1)

implement 3

public int trap(int[] height) {
        int sum = 0;
        int[] max_left = new int[height.length];
        int[] max_right = new int[height.length];

        for (int i = 1; i < height.length - 1; i++) {
            max_left[i] = Math.max(max_left[i - 1], height[i - 1]);
        }
        for (int i = height.length - 2; i >= 0; i--) {
            max_right[i] = Math.max(max_right[i + 1], height[i + 1]);
        }
        for (int i = 1; i < height.length - 1; i++) {
            int min = Math.min(max_left[i], max_right[i]);
            if (min > height[i]) {
                sum = sum + (min - height[i]);
            }
        }
        return sum;
    }

分析后记

好久没写了，之前因为各种事情耽搁了，还是得加油啊！