[leetcode] Trapping Rain Water

思路1：

        使用递归的方法，直接考虑该问题，对于任意的这样一组数据，如果要求能容的最多的水，有一点是确定的：如果我们能找到数组里面的最大的两个数，那个这两个数之间能容的最多的水是确定的。设数据为An，而最大的两个数依次为ai,aj, 且i>j, 则trap(An) = trap(A[0:i]) + trap(A[i,j]) + trap(A[j,n]), 此算法的时间复杂度为nlgn, accepted的代码如下：

class Solution {
public:
    int cal_trap(vector<int>&height, int left, int right) {
        int result = 0;
        int max_height = std::min(height[left], height[right]);
        for(int i=left+1; i<right; i++) {
            result += (max_height-height[i]);
        }
        return result;
    }
    int cur_trap(vector<int>& height, int left, int right){
        if (right-left <= 1) return 0;
        int max_h = left, next_h = left;
        int max_h_value = -1, next_h_value = -1;
        for(int i=left; i<=right;i++) {
            if(height[i] > max_h_value) {
                next_h_value = max_h_value;
                next_h = max_h;
                max_h = i;
                max_h_value = height[i];
            } else if(height[i] > next_h_value){
                next_h = i;
                next_h_value = height[i];
            }
        }
        int new_left = 0, new_right = 0;
        if (max_h > next_h) {
            new_left = next_h;
            new_right = max_h;
        } else {
            new_left = max_h;
            new_right = next_h;
        }
        return cal_trap(height, new_left, new_right) + cur_trap(height, left, new_left)
            + cur_trap(height, new_right, right);
    }
    int trap(vector<int>& height) {
        return cur_trap(height, 0, height.size()-1);
    }
};

 

思路2：

　　即是网上看到的时间复杂度为n的方法，利用stack结构，其原理是利用stack中只保存逐步递减的高度，然后，遇到比stack.top()的原理，则对结果进行加（相当于加水到某一高度），直接上代码：

class Solution {
public:
    
    int trap(vector<int>& height) {
        size_t s = height.size();
        if (s<3) return 0;
        int result = 0, bottom = 0;
        stack<int> slop;
        for (size_t i=0;i<height.size();i++) {
            while(!slop.empty() && height[i] >=height[slop.top()]) {
                bottom = height[slop.top()];
                int cal_loc = slop.top();
                slop.pop();
                if(!slop.empty()) {
                    result += (i-slop.top()-1) * (min(height[i], height[slop.top()])-bottom);
                }
            }
            slop.push(i);
        }
        return result;
    } 
};

思路3：

　　原理是对于某一位置，其上能容的最大的水是由其左边及右边的最高值确定的，即如果对ai, 其左边最高的值为al, 其右边最高的值为ar, 则在位置i, 其最多能容纳min(al, ar)-ai, 代码如下：

　　

class Solution {
public:
    
    int trap(vector<int>& height) {
        size_t s = height.size();
        if(s<3) return 0;
        vector<int> left_max(s, 0);
        vector<int> right_max(s, 0);
        int max_left_value=0, max_right_value = 0;
        for(size_t i=0;i<s;i++) {
            if (height[i]>max_left_value) {
                max_left_value = height[i];
            }
            if (height[s-1-i] > max_right_value) {
                max_right_value = height[s-1-i];
            }
            left_max[i] = max_left_value;
            right_max[s-1-i] = max_right_value;
        }
        int result = 0;
        for (size_t i= 0;i<s;i++) {
            result += std::min(left_max[i], right_max[i]) - height[i];
        }
        return result;
    }  
};