42.Trapping Rain Water

42.Trapping Rain Water
我的想法是通过两个指针，一个first，一个end。第一部分是从左到右遍历，如果end的高度大于等于first的高度，其实就是说明了可以形成一个坑位了，即中间有凹陷的地方。这是就可以计算了。为什么可以单独计算呢，因为，end指针在往右走，无论是比first大还是小，都和end的值没有关系了，因为first只能和第一个比height[first]高的形成一个水坑。first的选取值也是有说法的，必须是连续递增序列的末端才可以。因为如果是连续的是无法形成坑的。所以下一个步骤是计算坑的面积。然后让first = end，继续寻找下一个end。
如果经过之后，end到末尾了说明first所处位置是整个数组的最高点。那么需要从右向左遍历数组了。这部分就是和前面的方法一样了。同样是选择符合要求的first，然后再找end。
整个解题的思路是两个指针遍历。深入思考问题，发现水坑形成的原因，才能相出解题思路。下面是整个思路的代码，比较麻烦：

class Solution {
    public int trap(int[] height) {
        int size = height.length;
        if (height.length == 1 || height.length == 0){
            return 0;
        }
        int first = 0;
        int end = 0;
        int sum = 0;
        while (first < size){
            first = firstPosition(height, first);
            if (first >= size - 1){
                break;
            }
            end = first + 1;
            end = endPosition(height, first, end);
            if (end >= size){
                break;
            }
            int minHeight = Math.min(height[first], height[end]);
            for (int i = first+1; i < end; i++){
                sum += minHeight - height[i];
            }
            first = end;
        }
        if (first < size - 1){
            int STOP = first;
            first = size-1;
            while (first > STOP){
                while (first > STOP && height[first] <= height[first-1]){
                    first--;
                }
                if (first <= STOP){
                    break;
                }
                end = first-1;
                while (end > STOP && height[end] < height[first]){
                    end--;
                }
                int minHeight = Math.min(height[end] , height[first]);
                for (int i = end+1; i < first; i++){
                    sum += minHeight - height[i];
                }
                first = end;
            }
        }
        return sum;
    }
    public int firstPosition(int[] height, int begin){
        int size = height.length;
        while (begin+1 < size && height[begin] <= height[begin+1]){
            begin++;
        }
        return begin;
    }
    public int endPosition(int[] height, int first, int end){
        int size = height.length;
        while (end < size && height[end] < height[first]){
            end++;
        }
        return end;
    }
}

还有一个思路，和这个类似，但是比这个代码简单了很多。首先是找到符合要求的地方从两边向中间一起移动的，选择较小的边往内移动。直到在移动的过程找到比符合要求的指针高的位置，计算面积。这样可以边遍历变计算面积，而且可以保证一定会有一个终点，因为是选择从较小的边开始移动的。
代码如下：

class Solution {
    public int trap(int[] height) {
        int size = height.length;
        if (height.length == 1 || height.length == 0){
            return 0;
        }
        int first = 0;
        int end = 0;
        int sum = 0;
        while (first < size){
            first = firstPosition(height, first);
            if (first >= size - 1){
                break;
            }
            end = first + 1;
            end = endPosition(height, first, end);
            if (end >= size){
                break;
            }
            int minHeight = Math.min(height[first], height[end]);
            for (int i = first+1; i < end; i++){
                sum += minHeight - height[i];
            }
            first = end;
        }
        if (first < size - 1){
            int STOP = first;
            first = size-1;
            while (first > STOP){
                while (first > STOP && height[first] <= height[first-1]){
                    first--;
                }
                if (first <= STOP){
                    break;
                }
                end = first-1;
                while (end > STOP && height[end] < height[first]){
                    end--;
                }
                int minHeight = Math.min(height[end] , height[first]);
                for (int i = end+1; i < first; i++){
                    sum += minHeight - height[i];
                }
                first = end;
            }
        }
        return sum;
    }
    public int firstPosition(int[] height, int begin){
        int size = height.length;
        while (begin+1 < size && height[begin] <= height[begin+1]){
            begin++;
        }
        return begin;
    }
    public int endPosition(int[] height, int first, int end){
        int size = height.length;
        while (end < size && height[end] < height[first]){
            end++;
        }
        return end;
    }
}