Leetcode_trapping-rain-water(updated c++ and python version)

地址：http://oj.leetcode.com/problems/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.

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!

思路：分治法，在A中先找到最高的mid, 然后在（0，mid）找最高的, 记为left， 在（mid+1，A.legnth()）里找最高的，记为right

算出left到mid和mid到left之间的储水量，然后递归求trap(0, left) 和trap(right, A.length())

参考代码：

class Solution:
    # @param A, a list of integers
    # @return an integer
    def trap(self, A):
        if not A or len(A)<=2:return 0
        mid = max(A)
        mid_idx = A.index(mid)
        area=0
        if A[:mid_idx]:
            left = max(A[:mid_idx])
            left_idx = A.index(left)
            for i in range(left_idx, mid_idx):
                area += A[left_idx] - A[i]
            area += self.trap(A[:left_idx+1])

        if A[mid_idx+1:]:
            right = max(A[mid_idx+1:])
            for i in range(mid_idx+1, len(A)):
                if A[i] == right:
                    right_idx = i
                    break;
            for i in range(mid_idx+1, right_idx):
                area += A[right_idx] - A[i]
            area += self.trap(A[right_idx:])
            
        return area

c++ solution:

class Solution {
public:
    int trap(int A[], int n) {
        if(n<3)
            return 0;
        int ans = 0, maxheight = A[0], idx = 0;
        for(int i = 1; i<n; ++i)
        {
            if(A[i]>maxheight)
            {
                maxheight = A[i];
                idx = i;
            }
        }
        int left = idx-1, right = idx+1, lidx = 0, ridx = n-1;
        if(left>=1)
        {
            int maxleft = A[left];
            lidx = left;
            while(left>=0)
            {
                if(A[left]>maxleft)
                {
                    maxleft = A[left];
                    lidx = left;
                }
                --left;
            }
            for(int i = lidx+1; i<idx; ++i)
                ans += (maxleft-A[i]);
            ans += trap(A, lidx+1);
        }
        if(right<=n-2)
        {
            int maxright = A[right];
            ridx = right;
            while(right<n)
            {
                if(A[right]>maxright)
                {
                    maxright = A[right];
                    ridx = right;
                }
                ++right;
            }
            for(int i = idx+1; i<ridx; ++i)
                ans += (maxright-A[i]);
            ans += trap(A+ridx, n-ridx);
        }
        return ans;
    }
};