Leetcode - Trapping Rain Water

My code:

public class Solution {
    public int trap(int[] height) {
        if (height == null || height.length <= 1)
            return 0;
        int i = 0;
        while (i < height.length && height[i] == 0)
            i++;
        if (i >= height.length)
            return 0;
        Stack s = new Stack();
        int vol = 0;
        for (int j = i; j < height.length; j++) {
            if (s.isEmpty())
                s.push(j);
            else if (height[s.peek()] >= height[j]) {
                s.push(j);
            }
            else {
                int low = s.pop();
                while (!s.isEmpty()) {
                    int area = (Math.min(height[j], height[s.peek()]) - height[low]) * (j - s.peek() - 1);
                    vol += area;
                    if (height[j] < height[s.peek()])
                        break;
                    else
                        low = s.pop();
                }
                s.push(j);
            }
        }
        return vol;
    }
}

这道题木解法很多。我没有做出来。
这个是Stack的解法。
思路(参考)：
Use Stack to store the index of a bar;
If the current one is smaller then the top of the stack, push it to stack;
Otherwise, pop up the top until stack is empty or top is greater than the current one, add up the volume, push the current one to stack.

很像 histogram那道题目。
我们需要思考，为什么可以盛放水呢？因为后来的元素，突然变大了。
那么，和他边上的比他较小的元素，再边上的元素，横向构成了区域。
所以，用stack来做的化，区域面积都是横向的一块块累加起来的。
具体自己体会。
参考网页：
http://www.shuatiblog.com/blog/2014/05/14/Trapping-Rain-Water/

然后我自己写了下，用Array来做的方法。
My code:

public class Solution {
    public int trap(int[] height) {
        if (height == null || height.length <= 1)
            return 0;
        int[] left = new int[height.length];
        left[0] = height[0];
        int max = left[0];
        /** get the maximum left margin */
        for (int i = 1; i < height.length; i++) {
            if (max >= height[i])
                left[i] = max;
            else {
                max = height[i];
                left[i] = height[i];
            }
        }
        /** get the maximum right margin */
        int[] right = new int[height.length];
        right[height.length - 1] = height[height.length - 1];
        max = right[height.length - 1];
        for (int i = height.length - 2; i >= 0; i--) {
            if (max >= height[i])
                right[i] = max;
            else {
                max = height[i];
                right[i] = height[i];
            }
        }
        
        int vol = 0;
        for (int i = 0; i < height.length; i++)
            vol += Math.min(left[i], right[i]) - height[i];
        return vol;
    }
}

就是用两个数组left， right 来分别记录某个特定index，最大左边和最大右边分别是多少。
然后他可以盛放水的体积，就等于，较小的那个边 减去 他的value
这种做法，区域面积是纵向一块块加起来的。和Stack不一样。
这都是通过图片观察出来的。。
参考网页：
http://fisherlei.blogspot.com/2013/01/leetcode-trapping-rain-water.html

这道题目还有种做法，找到整个图片的最大值。然后从左到最大值，进行一次处理。
然后从右侧到最大值处，再进行一次处理。
My code:

public class Solution {
    public int trap(int[] height) {
        if (height == null || height.length <= 1)
            return 0;
        int maxIndex = 0;
        /** find the last index of maximum element */
        for (int i = 1; i < height.length; i++) {
            if (height[i] >= height[maxIndex])
                maxIndex = i;
        }
        
        int edge = 0;
        int vol = 0;
        for (int i = 1; i <= maxIndex; i++) {
            if (height[i] < height[edge]) {
                vol += height[edge] - height[i];
            }
            else {
                edge = i;
            }
        }
        edge = height.length - 1;
        for (int i = height.length - 2; i >= maxIndex; i--) {
            if (height[i] < height[edge]) {
                vol += height[edge] - height[i];
            }
            else {
                edge = i;
            }
        }
        return vol;
    }
}

这个算法复杂度同样也是扫描了两遍。但是！他的空间复杂度只是常数级别的。远胜于前两种做法！

这道题目分析了三种做法。花费了大量的时间和精力。Fuck.

Anyway, Good luck, Richardo!

My code:

public class Solution {
    public int trap(int[] height) {
        if (height == null || height.length == 0) {
            return 0;
        }
        
        int i = 0;
        int j = height.length - 1;
        int leftMax = height[i];
        int rightMax = height[j];
        int sum = 0;
        
        while (i <= j) {
            leftMax = Math.max(leftMax, height[i]);
            rightMax = Math.max(rightMax, height[j]);
            if (leftMax > rightMax) {
                sum += rightMax - height[j];
                j--;
            }
            else {
                sum += leftMax - height[i];
                i++;
            }
        }
        
        return sum;
    }
}

reference:
https://discuss.leetcode.com/topic/3016/share-my-short-solution

这个解法很巧妙，实在想不到。
这也是通过观察示意图得出来的解法，如果数学证明，应该很难。
i, j 分别指向两端。
然后那边最大值小一些，哪边先移动。
比如 leftMax < rightMax
那么 i 先向右移动。
移动之前，先看下，当前index对应的value，和 leftMax 的差值。如果当前value < leftMax, 那么这块水，一定是会存下来的。
为什么？
因为该处位置，一定不是整个图里面的最高点，所以他的水，一定有那个最高点给他存着。
这么说太抽象了，具体自己体会下吧。
比如
[2,1,0,4,2,3]
当index = 1时，这个时候， 在index = 1处，应该可以放水
(2-1)=1
为什么？因为最高点是4，所以，在3左侧，所有的水都可以存储下来。
所以每次是较小最大值的点移动，保证最大值一定在另一侧。
当i到达4时，这个时候 j 开始移动，可以发现,在 j = 4处，依然可以存点水(3-2) = 1, 因为最高点还在左边。

综上，可以求得总蓄水量。

time complexity: O(n)
space complexity: O(1)

下面介绍下栈的做法：
My code:

public class Solution {
    public int trap(int[] height) {
        if (height == null || height.length == 0) {
            return 0;
        }
        
        Stack st = new Stack();
        int sum = 0;
        int i = 0;
        while (i < height.length) {
            if (st.isEmpty() || height[st.peek()] >= height[i]) {
                st.push(i);
                i++;
            }
            else {
                int bottom = height[st.pop()];
                if (!st.isEmpty()) {
                    int hi = Math.min(height[st.peek()], height[i]) - bottom;
                    int wid = i - st.peek() - 1;
                    sum += hi * wid;
                }
            }
        }
        
        return sum;
    }
}
```

reference:
https://discuss.leetcode.com/topic/4939/a-stack-based-solution-for-reference-inspired-by-histogram

思路和 largest histogram 很像，具体就不赘述了。

Anyway, Good luck, Richardo! --  09/17/2016