leetcode $42 in cpp

Code: (This method is not the best one. There are other methods using two pointers)

Key: a bar could be a left bound if it is no less than its right. A bar could be a right bound if it is no less than its left. 

class Solution {
public:
int trap(vector<int>& height) {
if(height.empty()) return 0;
return find(height,0, height.size() - 1);
}
int find(vector<int> height,int left, int right){
if(left >=right - 1) return 0;

//find the left bound and the next closest right bound
int left_bound = -1;//next left bound that could hold the water
int right_bound = -1;//next closest right bound that could form a trap with left_bound

for(int i = left; i < height.size(); i ++){//find the left bound that could hold water
//two cases that it could not be a left bound:
//1. if height < 0
//2. if its right is no less than it
if(height[i] <= 0 || ( i + 1 < height.size() && height[i + 1] >= height[i])) continue;
left_bound = i;
break;
}
if(left_bound == -1 || left_bound >= height.size() - 2) return 0;

int right_bound_height = -1;
////find the next closest right bound that could hold water:
//during the iterations we need to find:
//1. temporary right bound candidates that could trap water with the left bound(rule: it is no
//   less than its right)
//2. the true right bound which is the highest bound among the right bound candidates(The
//   height of the true right bound among the candidates could be no less than or less than
//   the height of the left bound)
//   Briefly, if we find a right bound with height > height of leftbound, we immediately stop
//   if we could not find a right bound with height > height of leftbound, we choose the
//   tallst right bound among the right bound candidates found in 1.
for(int i = left_bound + 1; i <= right; i++){
//three cases that it could not be a right bound of a trap:
//1. if its height is <= 0
//2. if its left is no less than it
//3. if it is shorter than the current hightest right bound
if(height[i] <=0 || (i - 1 >= 0 && height[i-1] >=height[i]) || right_bound_height > height[i]) continue;
right_bound = i;
right_bound_height = height[i];
if(right_bound_height >= height[left_bound]) break;//once we find a right bound taller
//than the left bound, we terminate the loops.
}
if(right_bound == -1 || right_bound <= left_bound + 1) return 0;//cannot find right bound
//calculate the water trapped
int res = right_bound - left_bound - 1;
int min_height = height[right_bound]>height[left_bound]?height[left_bound]:height[right_bound];
res*= min_height;
//minus the volumes of barriers in the trap
for(int i = left_bound + 1; i < right_bound; i ++){
res -= height[i] > min_height?min_height:height[i];
}
//calculate the next pair of left bound and right bound.
return res + find(height, right_bound, right);
}
};