【数据结构与算法】之“接雨水”的算法求解

题目要求

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

示例1：

在这里插入图片描述

	输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
	输出：6
	解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。

示例 2：

	输入：height = [4,2,0,3,2,5]
	输出：9

提示：
- n == height.length
- 0 <= n <= 3 * 104
- 0 <= height[i] <= 105

示例算法

① 按行求

就是先求高度为 1 的水，再求高度为 2 的水，再求高度为 3 的水。整个思路就是，求第 i 层的水，遍历每个位置，如果当前的高度小于 i，并且两边有高度大于等于 i 的，说明这个地方一定有水，水就可以加 1。
如果求高度为 i 的水，首先用一个变量 temp 保存当前累积的水，初始化为 0。从左到右遍历墙的高度，遇到高度大于等于 i 的时候，开始更新 temp。更新原则是遇到高度小于 i 的就把 temp 加 1，遇到高度大于等于 i 的，就把 temp 加到最终的答案 ans 里，并且 temp 置零，然后继续循环。
先求第一行的水，即红色区域中的水，数组是 height = [ 0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1 ] 。
原则是高度小于 1，temp ++，高度大于等于 1，ans = ans + temp，temp = 0。
- temp 初始化为 0，ans = 0。
- height[0] 等于 0 < 1，不更新。
- height[1] 等于 1 >= 1，开始更新 temp。
- height[2] 等于 0 < 1，temp = temp + 1 = 1。
- height[3] 等于 2 >= 1，ans = ans + temp = 1，temp = 0。
- height[4] 等于 1 >= 1，ans = ans + temp = 1，temp = 0。
- height[5] 等于 0 < 1，temp = temp + 1 = 1。
- height[6] 等于 1 >= 1，ans = ans + temp = 2，temp = 0。
- 剩下的 height[7] 到最后，高度都大于等于 1，更新 ans = ans + temp = 2，temp = 0。而其实 temp 一直都是 0，所以 ans 没有变化。
再求第二行的水：也就是红色区域中的水，数组是 height = [ 0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1 ]。
原则是高度小于 2，temp ++，高度大于等于 2，ans = ans + temp，temp = 0。
- temp 初始化为 0，ans 此时等于 2。
- height[0] 等于 0 < 2，不更新。
- height[1] 等于 1 < 2，不更新。
- height[2] 等于 0 < 2，不更新。
- height[3] 等于 2 >= 2，开始更新
- height[4] 等于 1 < 2，temp = temp + 1 = 1。
- height[5] 等于 0 < 2，temp = temp + 1 = 2。
- height[6] 等于 1 < 2，temp = temp + 1 = 3。
- height[7] 等于 3 >= 2，ans = ans + temp = 5，temp = 0。
- height[8] 等于 2 >= 2，ans = ans + temp = 3，temp = 0。
- height[9] 等于 1 < 2，temp = temp + 1 = 1。
- height[10] 等于 2 >= 2，ans = ans + temp = 6，temp = 0。
- height[11] 等于 1 < 2，temp = temp + 1 = 1。
- 然后结束循环，此时的 ans 就是6。

在这里插入图片描述

再求第三层：按照之前的算法，之前的都是小于 3 的，不更新 temp，然后到 height[7] 等于 3，开始更新 temp，但是后边没有 height 大于等于 3 了，所以 ans 没有更新。所以最终的 ans 就是 6。
Java 示例：

public int trap(int[] height) {
    
    
    int sum = 0;
    // 找到最大的高度，以便遍历。
    int max = getMax(height);
    for (int i = 1; i <= max; i++) {
    
    
    	// 标记是否开始更新 temp
        boolean isStart = false; 
        int temp_sum = 0;
        for (int j = 0; j < height.length; j++) {
    
    
            if (isStart && height[j] < i) {
    
    
                temp_sum++;
            }
            if (height[j] >= i) {
    
    
                sum = sum + temp_sum;
                temp_sum = 0;
                isStart = true;
            }
        }
    }
    return sum;
}
private int getMax(int[] height) {
    
    
		int max = 0;
		for (int i = 0; i < height.length; i++) {
    
    
			if (height[i] > max) {
    
    
				max = height[i];
			}
		}
		return max;
}

时间复杂度：如果最大的数是 m，个数是 n，那么就是 O(m∗n)。
空间复杂度：O(1)。

② 按列求

求每一列的水，只需要关注当前列，以及左边最高的墙，右边最高的墙就够了。装水的多少，当然根据木桶效应，只需要看左边最高的墙和右边最高的墙中较矮的一个就够了。所以，根据较矮的那个墙和当前列的墙的高度可以分为三种情况。

Ⓐ 较矮的墙的高度大于当前列的墙的高度
在这里插入图片描述

把正在求的列左边最高的墙和右边最高的墙确定后，然后为了方便理解，我们把无关的墙去掉。
这样就很清楚了，现在想象一下，往两边最高的墙之间注水。正在求的列会有多少水？很明显，较矮的一边，也就是左边的墙的高度，减去当前列的高度就可以了，也就是 2 - 1 = 1，可以存一个单位的水。

Ⓑ 较矮的墙的高度小于当前列的墙的高度
在这里插入图片描述

同样的，我们把其他无关的列去掉。
想象下，往两边最高的墙之间注水。正在求的列会有多少水？正在求的列不会有水，因为它大于了两边较矮的墙。

Ⓒ 较矮的墙的高度等于当前列的墙的高度
在这里插入图片描述

和上一种情况是一样的，不会有水。

明白了这三种情况，程序就很好写了，遍历每一列，然后分别求出这一列两边最高的墙。找出较矮的一端，和当前列的高度比较，结果就是上边的三种情况。

Java 示例：

扫描二维码关注公众号，回复： 12279692 查看本文章

public int trap(int[] height) {
    
    
    int sum = 0;
    // 最两端的列不用考虑，因为一定不会有水。所以下标从 1 到 length - 2
    for (int i = 1; i < height.length - 1; i++) {
    
    
        int max_left = 0;
        // 找出左边最高
        for (int j = i - 1; j >= 0; j--) {
    
    
            if (height[j] > max_left) {
    
    
                max_left = height[j];
            }
        }
        int max_right = 0;
        // 找出右边最高
        for (int j = i + 1; j < height.length; j++) {
    
    
            if (height[j] > max_right) {
    
    
                max_right = height[j];
            }
        }
        // 找出两端较小的
        int min = Math.min(max_left, max_right);
        // 只有较小的一段大于当前列的高度才会有水，其他情况不会有水
        if (min > height[i]) {
    
    
            sum = sum + (min - height[i]);
        }
    }
    return sum;
}

③ 暴力法

对于数组中的每个元素，找出下雨后水能达到的最高位置，等于两边最大高度的较小值减去当前高度的值。
初始化 ans=0；
从左向右扫描数组：
- 初始化 max_left=0 和 max_right=0；
- 从当前元素向左扫描并更新：
  max_left=max(max_left,height[j])
- 从当前元素向右扫描并更新：
  max_right=max(max_right,height[j])
- 将min(max_left,max_right)−height[i] 累加到 ans。
C++ 示例：

int trap(vector<int>& height) {
    
    
    int ans = 0;
    int size = height.size();
    for (int i = 1; i < size - 1; i++) {
    
    
        int max_left = 0, max_right = 0;
        // Search the left part for max bar size
        for (int j = i; j >= 0; j--) {
    
     
            max_left = max(max_left, height[j]);
        }
        // Search the right part for max bar size
        for (int j = i; j < size; j++) {
    
     
            max_right = max(max_right, height[j]);
        }
		// cumulative 
        ans += min(max_left, max_right) - height[i];
    }
    return ans;
}

Java 示例：

public int trap(int[] height) {
    
    
    int ans = 0;
    int size = height.length;
    for (int i = 1; i < size - 1; i++) {
    
    
        int max_left = 0, max_right = 0;
        // Search the left part for max bar size
        for (int j = i; j >= 0; j--) {
    
     
            max_left = Math.max(max_left, height[j]);
        }
        // Search the right part for max bar size
        for (int j = i; j < size; j++) {
    
     
            max_right = Math.max(max_right, height[j]);
        }
        // cumulative
        ans += Math.min(max_left, max_right) - height[i];
    }
    return ans;
}

复杂性分析
- 时间复杂度：O(n²)，数组中的每个元素都需要向左向右扫描。
- 空间复杂度：O(1) 。

④ 动态编程

在暴力方法中，仅仅为了找到最大值每次都要向左和向右扫描一次。但是我们可以提前存储这个值。因此，可以通过动态编程解决。

在这里插入图片描述

思路分析：
- 找到数组中从下标 i 到最左端最高的条形块高度 left_max。
- 找到数组中从下标 i 到最右端最高的条形块高度 right_max。
- 扫描数组 height 并更新答案：累加 min(max_left[i],max_right[i])−height[i] 到 ans 上。
C++ 的示例：

int trap(vector<int>& height) {
    
    
    if (height == null)
        return 0;
    int ans = 0;
    int size = height.size();
    vector<int> left_max(size), right_max(size);
    left_max[0] = height[0];
    for (int i = 1; i < size; i++) {
    
    
        left_max[i] = max(height[i], left_max[i - 1]);
    }
    right_max[size - 1] = height[size - 1];
    for (int i = size - 2; i >= 0; i--) {
    
    
        right_max[i] = max(height[i], right_max[i + 1]);
    }
    for (int i = 1; i < size - 1; i++) {
    
    
        ans += min(left_max[i], right_max[i]) - height[i];
    }
    return ans;
}

Java 示例：

public int trap(int[] height) {
    
    
    if (height == null || height.length == 0)
        return 0;
    int ans = 0;
    int size = height.length;
    int[] left_max = new int[size];
    int[] right_max = new int[size];
    left_max[0] = height[0];
    for (int i = 1; i < size; i++) {
    
    
        left_max[i] = Math.max(height[i], left_max[i - 1]);
    }
    right_max[size - 1] = height[size - 1];
    for (int i = size - 2; i >= 0; i--) {
    
    
        right_max[i] = Math.max(height[i], right_max[i + 1]);
    }
    for (int i = 1; i < size - 1; i++) {
    
    
        ans += Math.min(left_max[i], right_max[i]) - height[i];
    }
    return ans;
}

复杂性分析：
- 时间复杂度：O(n)。
  - 存储最大高度数组，需要两次遍历，每次 O(n) 。
  - 最终使用存储的数据更新 ans ，O(n)。
- 空间复杂度：O(n) 额外空间：和暴力法相比，使用了额外的 O(n) 空间用来放置 left_max 和 right_max 数组。

⑤ 栈的应用

可以不用像方法 4 那样存储最大高度，而是用栈来跟踪可能储水的最长的条形块。使用栈就可以在一次遍历内完成计算。
我们在遍历数组时维护一个栈。如果当前的条形块小于或等于栈顶的条形块，将条形块的索引入栈，意思是当前的条形块被栈中的前一个条形块界定。如果发现一个条形块长于栈顶，可以确定栈顶的条形块被当前条形块和栈的前一个条形块界定，因此可以弹出栈顶元素并且累加答案到 ans 。
算法思路如下：
- 使用栈来存储条形块的索引下标；
- 遍历数组：
  - 当栈非空且 height[current]>height[st.top()]，意味着栈中元素可以被弹出。弹出栈顶元素 top。
  - 计算当前元素和栈顶元素的距离，准备进行填充操作 distance=current−st.top()−1；
  - 找出界定高度bounded_height=min(height[current],height[st.top()])−height[top]；
  - 往答案中累加积水量 ans+=distance×bounded_height；
- 将当前索引下标入栈；
- 将 current 移动到下个位置。
C++ 算法如下：

int trap(vector<int>& height) {
    
    
    int ans = 0, current = 0;
    stack<int> st;
    while (current < height.size()) {
    
    
        while (!st.empty() && height[current] > height[st.top()]) {
    
    
            int top = st.top();
            st.pop();
            if (st.empty())
                break;
            int distance = current - st.top() - 1;
            int bounded_height = min(height[current], height[st.top()]) - height[top];
            ans += distance * bounded_height;
        }
        st.push(current++);
    }
    return ans;
}

Java 算法如下：

public int trap(int[] height) {
    
    
    int ans = 0, current = 0;
    Deque<Integer> stack = new LinkedList<Integer>();
    while (current < height.length) {
    
    
        while (!stack.isEmpty() && height[current] > height[stack.peek()]) {
    
    
            int top = stack.pop();
            if (stack.isEmpty())
                break;
            int distance = current - stack.peek() - 1;
            int bounded_height = Math.min(height[current], height[stack.peek()]) - height[top];
            ans += distance * bounded_height;
        }
        stack.push(current++);
    }
    return ans;
}

复杂性分析
- 时间复杂度：O(n)，单次遍历 O(n) ，每个条形块最多访问两次（由于栈的弹入和弹出），并且弹入和弹出栈都是 O(1) 的。
- 空间复杂度：O(n)。栈最多在阶梯型或平坦型条形块结构中占用 O(n) 的空间。

⑥ 使用双指针

和方法 4 相比，我们不从左和从右分开计算，想办法一次完成遍历。
从动态编程方法的示意图中我们注意到，只要 right_max[i]>left_max[i] （元素 0 到元素 6），积水高度将由 left_max 决定，类似地 left_max[i]>right_max[i]（元素 8 到元素 11）。
所以可以认为如果一端有更高的条形块（例如右端），积水的高度依赖于当前方向的高度（从左到右）。当发现另一侧（右侧）的条形块高度不是最高的，则开始从相反的方向遍历（从右到左）。
必须在遍历时维护 left_max 和 right_max ，但是现在可以使用两个指针交替进行，实现一次遍历即可完成。
算法思路如下：
- 初始化 left 指针为 0 并且 right 指针为 size-1；
- While left<right, do:
  - If height[left] < height[right]
    - If height[left]≥left_max, 更新 left_max
    - Else 累加 left_max−height[left] 到 ans
    - left = left + 1
  - Else
    - If height[right]≥right_max, 更新 right_max
    - Else 累加 right_max−height[right] 到 ans
    - right = right - 1
C++ 示例：

int trap(vector<int>& height) {
    
    
    int left = 0, right = height.size() - 1;
    int ans = 0;
    int left_max = 0, right_max = 0;
    while (left < right) {
    
    
        if (height[left] < height[right]) {
    
    
            height[left] >= left_max ? (left_max = height[left]) : ans += (left_max - height[left]);
            ++left;
        }
        else {
    
    
            height[right] >= right_max ? (right_max = height[right]) : ans += (right_max - height[right]);
            --right;
        }
    }
    return ans;
}

Java 示例：

public int trap(int[] height) {
    
    
    int left = 0, right = height.length - 1;
    int ans = 0;
    int left_max = 0, right_max = 0;
    while (left < right) {
    
    
        if (height[left] < height[right]) {
    
    
            if (height[left] >= left_max) {
    
    
                left_max = height[left];
            } else {
    
    
                ans += (left_max - height[left]);
            }
            ++left;
        } else {
    
    
            if (height[right] >= right_max) {
    
    
                right_max = height[right];
            } else {
    
    
                ans += (right_max - height[right]);
            }
            --right;
        }
    }
    return ans;
}

复杂性分析
- 时间复杂度：O(n)，单次遍历的时间O(n)。
- 空间复杂度：O(1) 的额外空间。left, right，left_max 和 right_max 只需要常数的空间。

【数据结构与算法】之“接雨水”的算法求解

题目要求

示例算法

① 按行求

② 按列求

③ 暴力法

④ 动态编程

⑤ 栈的应用

⑥ 使用双指针

猜你喜欢