接雨水——单调栈的实践

 一、题目

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例:

输入: [0,1,0,2,1,0,1,3,2,1,2,1]
输出: 6

二、暴力破解法

假设每一列可以存水，只要我们遍历每一列，计算存水的总和即可。现在我们根据图上的显示，计算出第1列存水0，第2列存水0，第3列存水1，第4列存水0，第5列存水1，，，

如何计算当前列的水量？

1、计算出当前列左边最高的墙

2、计算出当前列右边最高的墙

3、比较这两个中最小的墙Min，如果大于当前列的高度，则计算当前列的水量；，小于等于代表没水，不用计算

4、计算当前列的水量=Min-当前列的高度

5、遍历所有列，将水量求和

int trap(vector<int>& height) {

int sum=0;
if(height.size()<3)
{
    return 0;

}

for(int i=1;i<=height.size()-1;i++)
{

    int LeftMax=0;
    int RightMax =0;
    int result =0;

    for(int j=i-1;j>=0;j--)
    {
        if(LeftMax<height[j])
        {
            LeftMax=height[j];
        }

    }

    for(int j=i+1;j<height.size();j++)
    {
        if(RightMax<height[j])
        {
            RightMax=height[j];
        }

 }

result= LeftMax>RightMax?RightMax:LeftMax;

if(result>height[i])
{
    sum = sum + (result-height[i]);
}

}

return sum;
}

三、暴力破解法的改进——动态规划

我们注意到，解法一中。对于每一列，我们求它左边最高的墙和右边最高的墙，都是重新遍历一遍所有高度，这里我们可以优化一下。首先用两个数组，max_left [i] 代表第 i 列左边最高的墙的高度，max_right[i] 代表第 i 列右边最高的墙的高度。（一定要注意下，第 i 列左（右）边最高的墙)

对于 max_left我们其实可以这样求。

max_left [i] = Max(max_left [i-1],height[i-1])。它前边的墙的左边的最高高度和它前边的墙的高度选一个较大的，就是当前列左边最高的墙了。

对于 max_right我们可以这样求。

max_right[i] = Max(max_right[i+1],height[i+1]) 。它后边的墙的右边的最高高度和它后边的墙的高度选一个较大的，就是当前列右边最高的墙了。

这样，我们再利用解法二的算法，就不用在 for 循环里每次重新遍历一次求 max_left 和 max_right 了

nt trap(vector<int>& height) 
{

if (height.size() == 0)
	{
		return 0;
	}

	int Length = height.size();
	int sum = 0;

	vector<int> max_left(Length);
	vector<int> max_right(Length);

	max_left[0] = height[0];

	for (int i = 1; i < Length; i++)
	{
		int temp = max(max_left[i - 1], height[i - 1]);
		max_left[i]=temp;
	}

	max_right[Length - 1] = height[Length - 1];

	for (int i = Length - 2; i >= 0; i--) {
		int temp = max(max_right[i + 1], height[i + 1]);
		max_right[i]=temp;
	}

	for (int i = 1; i < Length - 1; i++) {
		int temp = min(max_left[i], max_right[i]);
		if (temp > height[i]) {
			sum = sum + (temp - height[i]);
		}
	}

	return sum;

}

四、使用双指针

动态规划中，我们常常可以对空间复杂度进行进一步的优化。

例如这道题中，可以看到，max_left [ i ] 和 max_right [ i ] 数组中的元素我们其实只用一次，然后就再也不会用到了。所以我们可以不用数组，只用一个元素就行了。

height [ left - 1] 是可能成为 max_left 的变量， 同理，height [ right + 1 ] 是可能成为 right_max 的变量。

只要保证 height [ left - 1 ] < height [ right + 1 ] ，那么 max_left 就一定小于 max_right。

因为 max_left 是由 height [ left - 1] 更新过来的，而 height [ left - 1 ] 是小于 height [ right + 1] 的，而 height [ right + 1 ] 会更新 max_right，所以间接的得出 max_left 一定小于 max_right。

int trap(vector<int>& height) 
{

if (height.size() == 0)
	{
		return 0;
	}

	int Length = height.size();
	int sum = 0;
    int max_left = 0;
    int max_right = 0;
    int left = 1;
    int right = Length - 2; // 加右指针进去
    for (int i = 1; i < Length - 1; i++) {
        //从左到右更
        if (height[left - 1] < height[right + 1]) {
            max_left = max(max_left, height[left - 1]);
            int min = max_left;
            if (min > height[left]) {
                sum = sum + (min - height[left]);
            }
            left++;
        //从右到左更
        } else {
            max_right = max(max_right, height[right + 1]);
            int mintemp = max_right;
            if (mintemp > height[right]) {
                sum = sum + (mintemp - height[right]);
            }
            right--;
        }
    }
    return sum;



}

五、使用单调栈

我们用一个栈来保存每堵墙。

总体的原则就是，

    1、当前高度小于等于栈顶高度，入栈，指针后移。

   2、当前高度大于栈顶高度，出栈，计算出当前墙和栈顶的墙之间水的多少，然后计算当前的高度和新栈的高度的关系，重复第 2 步。直到当前墙的高度不大于栈顶高度或者栈空，然后把当前墙入栈，指针后移。

int trap(vector<int>& height) 
{

if (height.size() == 0)
	{
		return 0;
	}

    int sum = 0;
    stack<int>  destinStack;
    int current = 0;
    while (current < height.size()) {
        //如果栈不空并且当前指向的高度大于栈顶高度就一直循环
        while (!destinStack.empty() && height[current] > height[destinStack.top()]) 
        {
            int h = height[destinStack.top()]; //取出要出栈的元素
            destinStack.pop(); //出栈
            if (destinStack.empty()) { // 栈空就出去
                break; 
            }
            int distance = current - destinStack.top() - 1; //两堵墙之前的距离。
            int mintemp = min(height[destinStack.top()], height[current]);
            sum = sum + distance * (mintemp - h);
        }
        destinStack.push(current); //当前指向的墙入栈
        current++; //指针后移
    }
    return sum;

}