Trapping Rain Water

最新推荐文章于 2024-09-17 16:23:14 发布

原创最新推荐文章于 2024-09-17 16:23:14 发布 · 340 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode_Java 专栏收录该内容

121 篇文章

订阅专栏

本文详细介绍了如何通过不同的算法解决雨水收集问题，包括使用动态规划、两遍扫描和栈等方法来计算给定地形能捕捉多少雨水。

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.

For example,
Given [0,1,0,2,1,0,1,3,2,1,2,1], return 6.

The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. Thanks Marcos for contributing this image!

Have you been asked this question in an interview?
方法一： dp
两个for循环求出每个点左右两边的最高bar，再用一个for 循环求出对于每个点可以的存水量。
该方法还可以优化将求右边bar 和求最后结果合到一起
注意：要考虑到当前的a[i] 比左右两边的bar 高时，不进行操作

public class Solution {
    public int trap(int[] A) {
        if (A == null || A.length == 0) {
            return 0;
        }
        int[] leftBar = new int[A.length];
        leftBar[0] = 0;
        for (int i = 1; i < A.length; i++) {
            leftBar[i] = Math.max(leftBar[i - 1], A[i - 1]);
        }
        int[] rightBar = new int[A.length];
        rightBar[A.length - 1] = 0;
        for (int i = A.length - 2; i > 0; i--) {
            rightBar[i] = Math.max(rightBar[i + 1], A[i + 1]);
        }
        int res = 0;
        for (int i = 1; i < A.length - 1; i++) {
            if (Math.min(leftBar[i], rightBar[i]) > A[i]) {
                res += Math.min(leftBar[i], rightBar[i]) - A[i];
            }
        }
        return res;
    }
}

将第二个和第三个 for 循环合并后：

public class Solution {
    public int trap(int[] A) {
        if (A == null || A.length == 0) {
            return 0;
        }
        int[] leftBar = new int[A.length];
        leftBar[0] = 0;
        for (int i = 1; i < A.length; i++) {
            leftBar[i] = Math.max(leftBar[i - 1], A[i - 1]);
        }
        int right = A[A.length - 1] ;
        int res = 0;
        for (int i = A.length - 2; i > 0; i--) {
            if (Math.min(leftBar[i], right) > A[i]) {
                res += Math.min(leftBar[i], right) - A[i];
            }
            right = Math.max(right, A[i]);
        }
        return res;
    }
}

九章的解法与以上方法有点不同，但是也很好理解：

public class Solution {
    public int trap(int[] A) {
        int sum = 0;
        int max = -1;
        int maxIndex = -1;
        int prev;

        // find the highest bar
        for (int i = 0; i < A.length; i++) {
            if (max < A[i]) {
                max = A[i];
                maxIndex = i;
            }
        }

        // process all bars left to the highest bar
        prev = 0;
        for (int i = 0; i < maxIndex; i++) {
            if (A[i] > prev) {
                sum += (A[i] - prev) * (maxIndex - i);
                prev = A[i];
            }
            sum -= A[i];
        }

        // process all bars right to the highest bar
        prev = 0;
        for (int i = A.length - 1; i > maxIndex; i--) {
            if (A[i] > prev) {
                sum += (A[i] - prev) * (i - maxIndex);
                prev = A[i];
            }
            sum -= A[i];
        }

        return sum;
    }
}

还有一种比较聪明的方法是用stack，时间复杂度都是 o(n), 但是只用一次for 循环即可。这种方法和 Largest Rectangle in Histogram 有点像

public class Solution {
    public int trap(int[] A) {
    	Stack<Integer> pre = new Stack<Integer>();
    	int result = 0;
    	for(int i = 0; i < A.length; i++) {
    	    if(pre.isEmpty() || A[pre.peek()] > A[i]) {
    	        pre.push(i);
    	        continue;
    	    }
    	    int mid = pre.pop();
    	    if(pre.isEmpty()) pre.push(i);
    	    else {
    	        int left = pre.peek();
    	        result += (Math.min(A[left], A[i])-A[mid]) * (i-left-1);
    	        i--;
    	    }
    	}
    	return result;
    }
}