leetcode---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.

Solution 1: 

public class Solution {
    /**
	 * The algorithm in this solution is smart and the running time is O(n). We introduce 
	 * a stack to save the indices which correspond a sequence of decreasing elements of A.
	 * @param A -int array.
	 * @return int -total capacity
	 * @author Averill Zheng
	 * @version 2014-06-22
	 * @since JDK 1.7
	 */
	public int trap(int[] A) {
		int capacity = 0, length = A.length;
		if(length > 0){
			int max = A[0];
			Stack<Integer> maxIndex = new Stack<Integer>();
			maxIndex.push(0);
			for(int i = 1; i < length; ++i) {
				if(A[maxIndex.peek()] <= A[i]){
					if(max <= A[maxIndex.peek()]){ //case 1, 
						max = A[i];
						maxIndex.pop();
						maxIndex.push(i);
					}
					else{//case 2
						while(!maxIndex.empty() && A[maxIndex.peek()] <= A[i]){
							int temp = A[maxIndex.pop()];
							if(!maxIndex.empty())
							    capacity += (Math.min(A[maxIndex.peek()], A[i]) - temp) * (i - maxIndex.peek() - 1);
							    
						}
						maxIndex.push(i);
						max = Math.max(max, A[i]);
					}
				}
				else //case 3
					maxIndex.push(i);
			}	
		}
		return capacity; 
    }
}

　　

 solution2:

public class Solution {
    public int trap(int[] A) {
        int max = 0;
        if(A.length > 1){
            int[] result = new int[A.length];
            result[0] = 0;
            result[1] = 0;
            int largest = (A[0] <= A[1])? A[1]: A[0];
            int largestIndex = (A[0]<= A[1])? 1 : 0;
            for(int i = 2; i < A.length; ++i){
                int length = 0;
                int sum = 0;
                for(int j = i - 1; j > largestIndex; --j){
                    if(A[j] < A[i]){
                        ++length;
                        sum += A[j];
                    }
                    else
                        break;
                }
                if(length == 0)
                    result[i] = result[i - 1];
                else
                    result[i] = Math.min(A[i], A[i - length - 1]) * length - sum + result[i - length - 1] ;
                largest = (A[i] <= largest)? largest: A[i];
                if(largest == A[i])
                    largestIndex = i;
            }
            max = result[A.length - 1];
        }
        return max;
    }
}