407. 接雨水 II-小顶堆/广度优先遍历

407. 接雨水 II

思路1

使用小顶堆，按高度从小到大的顺序进行输出

刚开始将边界元素添加到小顶堆当中

遍历自己周围的4个位置，如果发现比自己的高度低，那么就将res加上他们之间的高度差。并将该遍历的位置加入到小顶堆当中，高度设置为他们之间的max。

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 cur = pq.top();
            pq.pop();

            for(int k=0;k<4;k++){
                int nx = cur.second / n + dirs[k];
                int ny = cur.second % n + dirs[k + 1];

                if(nx >= 0 && nx <m && ny >=0&&ny<n && !visit[nx][ny]){
                    if(heightMap[nx][ny] < cur.first){
                        res += cur.first - heightMap[nx][ny];
                    }
                    visit[nx][ny] = true;
                    pq.push({max(heightMap[nx][ny],cur.first), nx*n+ny});
                }
            }
        }
        return res;   
    }
};

思路2：广度遍历的方法：

先将能够接到水的高度设置为高度最大

边界的水高度肯定和自身高度一致，并添加到队列中

当队列不为空时，弹出栈顶

比较自己与自己周围的水高度的值

当周围大于自己时，就要调整周围的水高度，（得按小的算

并将周围添加到队列中

最后将水高度减去自身高度就是最后的盛水量，相加

class Solution {
public:
    int trapRainWater(vector<vector<int>>& heightMap) {
        int m = heightMap.size(), n = heightMap[0].size();
        int maxHeight = 0;
        int dirs[] = {-1, 0, 1, 0, -1};

        for (int i = 0; i < m; ++i) {
            maxHeight = max(maxHeight, *max_element(heightMap[i].begin(), heightMap[i].end()));
        }
        vector<vector<int>> water(m, vector<int>(n, maxHeight));
        queue<pair<int,int>> qu;
        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) {
                    if (water[i][j] > heightMap[i][j]) {
                        water[i][j] = heightMap[i][j];
                        qu.push(make_pair(i, j));
                    }
                }
            }
        }        
        while (!qu.empty()) {
            int x = qu.front().first, y = qu.front().second;
            qu.pop();
            for (int i = 0; i < 4; ++i) {
                int nx = x + dirs[i], ny = y + dirs[i + 1];
                if (nx < 0 || nx >= m || ny < 0 || ny >= n) {
                    continue;
                }
                
                if (water[x][y] < water[nx][ny] && water[nx][ny] > heightMap[nx][ny]) {
                    water[nx][ny] = max(water[x][y], heightMap[nx][ny]);
                    qu.push(make_pair(nx, ny));
                }
            }
        }

        int res = 0;
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                res += water[i][j] - heightMap[i][j];
            }
        }
        return res;
    }
};