文章目录
42.接雨水
题目描述：
给定n个非负整数表示每个宽度为1的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水
思路：
依次看每根柱子能接多少雨水。
某根柱子能接的雨水，取决于该柱子左侧的最高柱子leftMax，和右侧的最高柱子rightMax。根据木桶效应，能接的水取决于左右两侧最高柱子的较小者，即h = min(leftMax,rightMax)，若h比当前柱子大，则当前柱子能接到的雨水。那么一个比较直观的思路就是，我们先预处理出每个位置的左侧最大值和右侧最大值，然后再遍历一次，在每个柱子的位置接雨水即可。
class Solution {
public int trap(int[] height) {
int n = height.length;
int[] leftMax = new int[n];
int[] rightMax = new int[n];
leftMax[0] = height[0];
rightMax[n - 1] = height[n - 1];
for (int i = 1; i < n; i++) {
leftMax[i] = Math.max(leftMax[i - 1], height[i]);
}
for (int i = n - 2; i >= 0; i--) {
rightMax[i] = Math.max(rightMax[i + 1], height[i]);
}
int ans = 0;
for (int i = 0; i < n; i++) {
int h = Math.min(leftMax[i], rightMax[i]);
if (h > height[i]) ans += h - height[i];
}
return ans;
}
}
上面两次预处理，加一次遍历计算，总共花费的时间为3n，其实可以优化为2n，我们可以先预处理出rightMax，然后，再边维护leftMax，边接雨水。
class Solution {
public int trap(int[] height) {
int n = height.length;
int[] rightMax = new int[n];
rightMax[n - 1] = height[n - 1];
for (int i = n - 2; i >= 0; i--) {
rightMax[i] = Math.max(rightMax[i + 1], height[i]);
}
int ans = 0, leftMax = height[0];
for (int i = 1; i < n; i++) {
leftMax = Math.max(leftMax, height[i]);
int h = Math.min(leftMax, rightMax[i]);
if (h > height[i]) ans += h - height[i];
}
return ans;
}
}
实际上，我们还可以用双指针来进行优化，只需要遍历一次即可算出答案。
核心的思路是：用2个指针，i从左往右移动，j从右往左移动。我们能够在过程中正确维护i的左侧最大值，和j的右侧最大值，然后我们每次计算在i或者j处的接雨水的量。
我们用iLeftMax表示位置i处左侧的最高柱子高度，iRightMax表示i右侧最高的柱子高度。jLeftMax和jRightMax同理。
我们在双指针的遍历过程中，能够得到iLeftMax和jRightMax的值。
由于i在j的左侧，我们容易得知如下关系：iLeftMax <= jLeftMax。因为j左侧的最大值，要么是i左侧的最大值，要么是i和j之间出现了比iLeftMax更大的值。
同样，容易得到：iRightMax >= jRightMax，因为i比j要多考虑区间[i,j]，iRightMax只可能比jRightMax更大。
整理一下，我们有：
iLeftMax <= jLeftMax
iRightMax >= jRightMax
并且我们能获取到iLeftMax和jRightMax的值。
当iLeftMax <= jRightMax时，根据上面的关系，有iLeftMax <= jRightMax <= iRightMax，进而有iLeftMax <= iRightMax，此时位置i能接的雨水，只取决于iLeftMax，而iLeftMax我们是已知的，所以此时可以计算i处的雨水。
当iLeftMax > jRightMax时，根据上面的关系，有jLeftMax >= iLeftMax > jRightMax，进而有jLeftMax > jRightMax，此时位置j能接的雨水，只取决于jRightMax，而jRightMax我们是已知的，所以此时可以计算j处的雨水。
双指针优化后，只需要一趟遍历即可完成计算。
class Solution {
public int trap(int[] height) {
int n = height.length;
int leftMax = height[0], rightMax = height[n - 1];
int i = 1, j = n - 2;
// iLeftMax <= jLeftMax
// iRightMax >= jRightMax
int ans = 0;
while (i <= j) {
if (leftMax <= rightMax) {
// iLeftMax <= jRightMax <= iRightMax
leftMax = Math.max(leftMax, height[i]);
ans += leftMax - height[i];
i++;
} else {
// jLeftMax >= iLeftMax > jRightMax
rightMax = Math.max(rightMax, height[j]);
ans += rightMax - height[j];
j--;
}
}
return ans;
}
}
其余解法：单调栈。
换个角度考虑，什么时候某个位置可能接到雨水呢，是不是只有柱子高度先下降，后上升，形成一个 “盆地”时（一个V字形），在中间的低洼处才能接到水呢？于是我们考虑用单调栈。栈里面存的是高度递减的柱子，从左往右遍历的时候，只要遇到一个比栈顶的柱子高度大的，则说明能和前面的柱子形成一个低洼处，能够接到雨水。
class Solution {
public int trap(int[] height) {
int n = height.length;
int[] stack = new int[n];
int top = -1; // 栈顶
int ans = 0;
for (int i = 0; i < n; i++) {
// 栈非空, 且栈顶的柱子高度小于当前柱子, 则开始接雨水
while (top >= 0 && height[stack[top]] < height[i]) {
int j = stack[top--]; // 准备接j这个位置的雨水
if (top < 0) break; // 没有前一个柱子了, 无法接j处的雨水
int k = stack[top]; // k和i围住了j, 可以接j处雨水, 注意不要把k也弹出栈
int minH = Math.min(height[k], height[i]);
ans += (minH - height[j]) * (i - k - 1);
}
// 该柱子能和前面的柱子接的雨水, 计算完毕, 插入该柱子
stack[++top] = i;
}
return ans;
}
}
407.接雨水II
题目描述：
给你一个 m x n 的矩阵，其中的值均为非负整数，代表二维高度图每个单元的高度，请计算图中形状最多能接多少体积的雨水。
上一道题是一维的，这道题是二维的。
思路：
第一次见这道题时，不太容易想清楚 [满足什么条件才能接到雨水] 这一点。比较直觉但是错误的想法是，对于某个位置[i,j]，找到其上下左右4个方向上，高度最大的4根柱子，取4根柱子中高度最小的，再和当前这跟柱子比较高度。
这样是错误的，水还可能从其他边边角角的地方流走。一种相对正确但是不太好想象的想法是：对于[i,j]，找到其四周围成一圈的一堵墙，这堵墙中，高度最小的柱子，再和[i,j]的柱子比高度。但这种想法很难付诸实践。
我们换个角度来看，当下完雨后，每个柱子有个最终高度，若这个最终高度大于该柱子原有高度，则说明在这个柱子的位置，接到了雨水。我们用f(i,j)来表示在位置[i,j]处的柱子的最终高度。引入这个最终高度的概念后，就很好想了。
f(i,j)，其实就取决于其周围4个相邻位置的最终高度。容易得到状态转移方程如下：
f(i,j) = max{ min{f(i-1, j), f(i + 1, j), f(i, j - 1), f(i, j + 1)}, height[i][j] }
即，位置[i,j]的柱子的最终高度，为其4个相邻位置的最终高度的最小值，再和[i,j]柱子原本的高度取一个max。
然后是状态的边界。容易得知，整个矩形最外层的柱子，都是接不到水的，水一定会从边界流出去。所以对所有最外层的柱子，初始化其f(i,j) = height[i][j]。我们每次，从已经求得f(i,j)的柱子中，找到f(i,j)值最小的，并更新其相邻的，还未求出f(i,j)的柱子。
为什么这样能求出正确答案。首先，根据木桶效应，f(i,j)只取决于其相邻的4个位置的最小者。所以我们每次从已经确定f(i,j)的柱子中，找出值最小的。假设我们选中的f(i,j)最小的柱子是a。那么， 与柱子a相邻的柱子，其f(i,j)一定是由柱子a转移过来的吗？
答案是肯定的，假设与柱子a相邻的某个柱子b，其还有其他3个相邻的柱子，若这3个相邻的柱子的最终高度已经求出，而我们选择的最小值为柱子a，说明这3个相邻柱子的最终高度都大于柱子a的。若这3个相邻的柱子里，有些柱子的最终高度还没有求出，则这些还没有求出最终高度的柱子，其最终高度，都是由已经求出最终高度的某根柱子转移过来的，而状态转移的过程中，f(i,j)只可能增大，不可能变小，所以这些没有求出最终高度的柱子的最终高度，一定是大于其状态转移链的初始那个状态，而这个初始状态一定是此时f(i,j)已知的，而此时已知的f(i,j)中，柱子a是最小的。也能够推出，其他3个相邻柱子的最终高度都一定大于a。所以柱子b的最终高度，一定是由柱子a的状态更新过来的。
再换个角度想，我们将最外层的柱子的状态f(i,j)进行了初始化，相当于在最外圈，围起了一堵墙（边界），这堵墙中间的某根柱子，是否能接到水，一定取决于最外圈这堵墙中（边界上），高度最小的那根柱子。所以我们每次需要取高度最小的。
于是，我们的算法就出来了。其实和Dijkstra特别像。每次从f(i,j)已知的柱子中，选择一个最小的，更新其相邻的柱子。我们用小根堆来做。
class Solution {
class Node {
int x;
int y;
int h; // 下雨之后该柱子的最终高度
Node(int x, int y, int h) {
this.x = x;
this.y = y;
this.h = h;
}
}
public int trapRainWater(int[][] heightMap) {
int n = heightMap.length, m = heightMap[0].length;
boolean[][] st = new boolean[n][m]; // 用来标记那些已经算出最终高度的柱子
// 按最终高度从小到大
PriorityQueue<Node> heap = new PriorityQueue<>((o1, o2) -> o1.h - o2.h);
// 将矩阵最外层的柱子插进堆
for (int i = 0; i < m; i++) {
heap.offer(new Node(0, i, heightMap[0][i])); // 第一行
heap.offer(new Node(n - 1, i, heightMap[n - 1][i])); // 最后一行
st[0][i] = st[n - 1][i] = true;
}
// 重复元素不影响最终答案
for (int i = 0; i < n; i++) {
heap.offer(new Node(i, 0, heightMap[i][0])); // 第一列
heap.offer(new Node(i, m - 1, heightMap[i][m - 1])); // 最后一列
st[i][0] = st[i][m - 1] = true;
}
int ans = 0;
int[] dx = {1, -1, 0, 0};
int[] dy = {0, 0, 1, -1};
while (!heap.isEmpty()) {
Node node = heap.poll();
for (int i = 0; i < 4; i++) {
int nx = node.x + dx[i];
int ny = node.y + dy[i];
if (nx < 0 || nx >= n || ny < 0 || ny >= m || st[nx][ny]) continue; // 越界或已求出最终高度
ans += Math.max(node.h, heightMap[nx][ny]) - heightMap[nx][ny]; // 接雨水
heap.offer(new Node(nx, ny, Math.max(node.h, heightMap[nx][ny])));
st[nx][ny] = true; // 该柱子已求出最终高度
}
}
return ans;
}
}
上面的思路是我自己看了yxc的视频讲解后，总结的一种比较简单，方便记忆和理解的思路。
yxc的原思路。其证明和推导过程十分严谨，但不是特别容易理解。
