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

.

自己第一个思路：（最蠢的，勿参考，提交后当数量比较大时会超时）

1.先对头和尾进行判断，两个指针移动，知道前后都不是0.（开头和结尾都是0是不能存储水的）

如：对以上数列，begin=1,end=len-1.

2.循环中：while(begin < end)

1）对这个数列进行遍历一遍，找到为0的个数就是蓄水的数量。遍历结束后，将这个值加到总和上去；

2）然后再遍历这个数列，找到最小的那一个的长度min（如果min为0，就将min设为1）；

3）再遍历一遍，将每个数减去min,得到每个数的新的长度。若得到的长度为负数，置为0；

4）再对begin和end进行处理，找到前后都不是0的位置，重置begin和end的值；

3.循环结束后，得到的总和就是需要的结果。

4.附上代码：（虽然很挫，但不能作为思路参考）

int trap(vector<int>& height) {
int len = height.size();
if(len < 3)
return 0;
int j = 0;
while(height[j]==0 && j < len) //找到第一个不是0的位置
j++;
if(j == len && j >=0) //都是0
return 0;
int beg = j;
j = len-1;
while(height[j]==0)
j--;
int end = j;//忽略后面都是0的位置
int sum = 0;
while(beg < end){
int sum_part = 0;
for(int k = beg; k <= end; k++){
if(height[k] == 0)
sum_part ++;
}
sum+=sum_part;
int min = INT_MAX;
for(int k = beg; k <= end; k++){
if(height[k]<min)
min = height[k];
}
if(min <= 0) min = 1;
for(int k = beg; k <= end; k++){
if(height[k]-min < 0)
height[k] = 0;
else
height[k] = height[k]-min;
}
j = 0;
while(height[j]==0 && j < len) //找到第一个不是0的位置
j++;
beg = j;
j = len-1;
while(height[j]==0 && j >= 0)
j--;
end = j;
}
return sum;
}

2.自己的思路二：

用栈。

1. 遍历每个数，若小于下一个数，就将其压入栈中；

2. 否则，判断将栈中小于当前数的那些数取出来；直到取到stack.top() >current为止

3. 若取到栈为空了，则判断栈中最后个元素和当前元素谁更大，则进行计算

4.若栈为空，则把当前元素加入栈中；否则，将之前的那些个数仍加入栈中

int trap(vector<int>& height) {
int len = height.size();
if(len < 3)
return 0 ;
int j = 0;
while(height[j] == 0 && j < len)
j++;
if(j == len)
return 0;
int beg = j;
j = len - 1;
while(height[j] == 0 && j >= 0)
j--;
int end = j;
stack<int> stk;
stk.push(height[beg]);
int former = height[beg];
beg++;
int sum = 0;
while(beg<=end){
if(height[beg] <= stk.top()){
stk.push(height[beg]);
beg++;
}else{
int num = 0;
int sum_part = 0, sum_all = 0;
while(!stk.empty()&& height[beg] > stk.top()){
sum_all += stk.top();
num++;
stk.pop();
}
if(!stk.empty()){
sum_part = height[beg]*num - sum_all;
for(int k = 0; k <= num; k++){
stk.push(height[beg]);
}
}else{
sum_part = former*num - sum_all;
former = height[beg];
stk.push(height[beg]);
}
sum += sum_part;
beg++;
}
}
return sum;
}

3.别人的好的思路和代码

class Solution {
public:
int trap(int A[], int n) {
int left=0; int right=n-1;
int res=0;
int maxleft=0, maxright=0;
while(left<=right){
if(A[left]<=A[right]){
if(A[left]>=maxleft) maxleft=A[left];
else res+=maxleft-A[left];
left++;
}
else{
if(A[right]>=maxright) maxright= A[right];
else res+=maxright-A[right];
right--;
}
}
return res;
}
};

4.同上

1) With left and right index.

int trap(vector<int>& height) {
int l = 0, r = height.size()-1, level = 0, water = 0;
while (l < r) {
int lower = height[height[l] < height[r] ? l++ : r--];
level = max(level, lower);
water += level - lower;
}
return water;
}

2)With left and right iterator.

int trap(vector<int>& height) {
auto l = height.begin(), r = height.end() - 1;
int level = 0, water = 0;
while (l != r + 1) {
int lower = *l < *r ? *l++ : *r--;
level = max(level, lower);
water += level - lower;
}
return water;
}