接雨水问题

接雨水问题有二维接雨水问题和三维接雨水问题，解题思路从整体上看还是有较大差异。

二维接雨水问题

双指针法：

My Code：

class Solution {
public:
    int trap(vector<int>& height) {
        int len = height.size();
        int l = 0, r = len - 1;
        while (l < r && height[l] == 0) l++;
        while (l < r && height[r] == 0) r--;
        int ans = 0;
        while (l < r) {
            if (height[l] > height[r]) {
                int p = r - 1;
                while (height[l] > height[p]) {
                    if (height[p] < height[r]) {
                        ans += height[r] - height[p];
                    } else {
                        r = p;
                    }
                    p--;
                }
                r = p;
            } else {
                int p = l + 1;
                while (height[r] > height[p]) {
                    if (height[p] < height[l]) {
                        ans += height[l] - height[p];
                    } else {
                        l = p;
                    }
                    p++;
                }
                l = p;
            }
        }
        return ans;
    }
};

Demo Code：

class Solution {
public:
    int trap(vector<int>& height) {
        int len = height.size();
        int leftMaxHeight = height[0];
        int rightMaxHeight = height[len-1];
        int left = 0, right = len - 1;
        int ans = 0;
        while (left <= right) {
            leftMaxHeight = max(leftMaxHeight, height[left]);
            rightMaxHeight = max(rightMaxHeight, height[right]);
            if (height[left] < height[right]) {
                ans += leftMaxHeight - height[left];
                left++;
            } else {
                ans += rightMaxHeight - height[right];
                right--;
            }
        }
        return ans;
    }
};

如果对问题理解的不是很透彻的话，很难写出简洁的代码。

二维接雨水问题主要的思想是：在遍历的过程中找出左边和右边中最大高度，如果当前位置的高度小于最大高度的话，就可以接到雨水；等于的话就接不到雨水。在遍历的过程中，先遍历小的那一端，用于保证可以接到尽可能多的雨水。

另外，还可以使用动态规划和单调栈的方法来解决该问题。

三维接雨水问题

最外层的一圈肯定是接不到雨水的，把最外层的高度放入优先队列（小根堆）中，找出最小的一个，判断该方格上下左右四个方向上的方格上能够盛放多少雨水？并将这4四个方格的高度放入最小堆中，从而更新最外层的最小高度（把最外层的最小高度变高）。同时，需要使用一个二维数组来标记该方格是否已经被遍历过。

Code：

typedef pair<int, int> pii;

class Solution {
public:
    int trapRainWater(vector<vector<int>>& heightMap) {
        if (heightMap.size() <= 2 || heightMap[0].size() <= 2) return 0;
        int m = heightMap.size();
        int n = heightMap[0].size();
        priority_queue<pii, vector<pii>, greater<pii>> pq;
        vector<vector<bool>> visit(m, vector<bool>(n, false));
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (i == 0 || i == m - 1 || j == 0 || j == n - 1) {
                    pq.push({heightMap[i][j], i*n+j});
                    visit[i][j] = true;
                }
            }
        }

        int res = 0;
        int dirs[] = {-1, 0, 1, 0, -1};
        while (!pq.empty()) {
            pii curr = pq.top();
            pq.pop();
            for (int k = 0; k < 4; ++k) {
                int nx = curr.second / n + dirs[k];
                int ny = curr.second % n + dirs[k+1];
                if (nx >= 0 && nx < m && ny >= 0 && ny < n && !visit[nx][ny]) {
                    if (heightMap[nx][ny] < curr.first)
                        res += curr.first - heightMap[nx][ny];
                    visit[nx][ny] = true;
                    pq.push({max(heightMap[nx][ny], curr.first), nx * n + ny});
                }
            }
        }

        return res;
    }
};

上面的代码中有一个值得学习的地方是——记录方格位置的时候使用了一个转换公式（nx * n + ny)把原来的两个数变成了一个数。