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.

The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. Thanks Marcos for contributing this image!

class Solution {
public:
    int trap(int A[], int n) {
		if(n == 0 || n == 1)
			return 0;
		int start = 0, cur = 1, max = INT_MIN, total = 0, maxIndex = -1;
		while(cur < n)
		{
			if(A[cur] >= A[start])
			{
				total += calculate(start, cur, &A[0]);
				start = cur;
				cur = start+1;
				max = INT_MIN;
				maxIndex = -1;
				continue;
			}
			if(A[cur] > max)
			{
				max = A[cur];
				maxIndex = cur;
			}
			cur++;
		}
		while(start != n-1)
		{
			total += calculate(start, maxIndex, &A[0]);
			start = maxIndex;
			maxIndex = getMax(start, n, &A[0]);
		}
		return total;
        
    }

	int calculate(int start, int end, int A[])
	{
		if(end - start <= 1)
			return 0;
		int measure = A[start] < A[end] ? A[start] : A[end];
		int total = 0;
		for(int i = start+1; i < end; i++)
		{
			total += (measure - A[i]);
		}
		return total;
	}
	int getMax(int start, int end, int A[])
	{
		int max = INT_MIN;
		int maxIndex = 0;
		for(int i = start+1; i < end; i++)
		{
			if(A[i] > max)
			{
				max = A[i];
				maxIndex = i;
			}
		}
		return maxIndex;
	}
};

Round 2:

 
class Solution
{
public:
int trap(int A[], int n) {
        if(n == 0)
            return 0;
        int max[n] = {0};
        int m = 0;
        int result = 0;
        for(int i = 0; i < n; i++)
        {
            max[i] = m;
            if(A[i] > m)
                m = A[i];
        }
        m = 0;
        for(int i = n-1; i >= 0; i--)
        {
            result += ((std::min(max[i], m) - A[i]) > 0 ? (std::min(max[i], m) - A[i]) : 0);
            if(A[i] > m)
                m = A[i];
        }
        return result;
    }
};