LintCode 364: Trapping Rain Water II (3维蓄水池问题，最小堆经典题)

364. Trapping Rain Water II
     Given n x m non-negative integers representing an elevation map 2d where the area of each cell is 1 x 1, compute how much water it is able to trap after raining.

Example
Given 5*4 matrix

[12,13,0,12]
[13,4,13,12]
[13,8,10,12]
[12,13,12,12]
[13,13,13,13]
return 14.

这题我感觉比较难。参考的网上的思路。
其实思路和LintCode 363 Trapping Rain Water(2维)差不多。每个格子上蓄的水都是该格子到边界上个的各个路径上的最大值的最小值与该格子高度之差。
注意：

1. 要找到各个最大值中的最小值，就必须用最小堆。
2. 从边上往里找，找到比当前结点更高的节点就放入最小堆。这个和2维的情况是一样的。2维是用两个指针从两边往中间找，这两个指针就相当于最小堆。每次更新当前路径的最高值(如果当前节点比堆的top高，或比指针指向的节点高)，然后再把该节点上方的水加入到结果里去。
3. 小结蓄水池算法：2维用反项双指针，3维用最小堆。
4. 与直方图问题区别：
   直方图问题(LintCode 122. Largest Rectangle in Histogram)是对每个矩形，找到往左和往右第一个小于它高度的矩形。解法是用单调递增栈。
   蓄水池问题是对每个矩形或立方体，找到它通往边界的所有路径上的最大值中的最小值，解法是用最小堆(3维)或反向双指针(2维)。

代码如下：

struct Node {
    int x;
    int y;
    int z;
    Node(int row = 0, int col = 0, int height = 0) : x(row), y(col), z(height) {}
};

struct cmp {
    bool operator() (Node & a, Node & b) {
        return a.z >= b.z;
    }
};

class Solution {
public:
    /**
     * @param heights: a matrix of integers
     * @return: an integer
     */
    int trapRainWater(vector<vector<int>> &heights) {
        
        vector<int> dx = {1, -1, 0, 0};
        vector<int> dy = {0, 0, 1, -1};
        
        if (heights.size() == 0) return 0;
        
        int count = 0;  //amount of water
        int m = heights.size();
        int n = heights[0].size();
        
        vector<vector<int>> visited(m, vector<int>(n, 0));
        priority_queue<Node, vector<Node>, cmp> minHeap;
        
        //push the boundary nodes to the minHeap
        for (int i = 0; i < m; ++i) {
            minHeap.push(Node(i, 0, heights[i][0]));
            minHeap.push(Node(i, n - 1, heights[i][n - 1]));
            visited[i][0] = true;
            visited[i][n - 1] = true;
        }
        
        //push the boundary nodes to the minHeap
        for (int i = 0; i < n; ++i) {
            minHeap.push(Node(0, i, heights[0][i]));
            minHeap.push(Node(m - 1, i, heights[m - 1][i]));
            visited[0][i] = true;
            visited[m - 1][i] = true;
        }
        
        while(!minHeap.empty()) {
            Node topNode = minHeap.top();
            minHeap.pop();
            
            for (int i = 0; i < 4; ++i) {
                int newX = topNode.x + dx[i];
                int newY = topNode.y + dy[i];
                
                if (newX < 0 || newX >= m || newY < 0 || newY >=n || visited[newX][newY]) 
                    continue;
                
                visited[newX][newY] = true;
                
                minHeap.push(Node(newX, newY, max(topNode.z, heights[newX][newY])));
                
                if (topNode.z > heights[newX][newY]) 
                    count += topNode.z - heights[newX][newY];
            }
        }
        
        return count;
    }
};