题目要求
给定 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(n2),数组中的每个元素都需要向左向右扫描。
- 空间复杂度: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 数组。
- 时间复杂度:O(n)。
⑤ 栈的应用
-
可以不用像方法 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
- If height[left] < height[right]
- 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 只需要常数的空间。