# Trapping Rain Water II LeetCode Solution

Difficulty Level Hard

## Problem Statement:

Trapping Rain Water II LeetCode Solution : Given an `m x n` integer matrix `heightMap` representing the height of each unit cell in a 2D elevation map, return the volume of water it can trap after raining.

## Examples:

Input:

``` heightMap = [[1,4,3,1,3,2],[3,2,1,3,2,4],[2,3,3,2,3,1]]
```

Output:

``` 4
```

Explanation:

```After the rain, water is trapped between the blocks.
We have two small ponds 1 and 3 units trapped.
The total volume of water trapped is 4.```

## Approach:

### Idea:

The idea is to consider all the boundary cells and then slowly cover the entire matrix with the help of BFS. One thing to remember is that the boundary cells can not store any amount of water in them. The idea is using Priority Queue (implemented with Min Heap) to polling out the node with minimum value. Then applying BFS algorithm to traverse through neighbor nodes.

While doing BFS we will check if the internal cells can store some amount of water in them.

First, we add all the boundary cells into a min-heap and then for each element i inside the min heap we do a BFS to its neighboring cells and calculate what amount of water they can store without the water getting spill out, by taking the ith element as the limiting boundary.

### Code:

Trapping Rain Water II C++ Solution:

```class Solution {
public:
int trapRainWater(vector<vector<int>>& heightMap) {
priority_queue<vector<int>> minHeap;
int m = heightMap.size();
int n = heightMap.size();
vector<vector<bool>> vis(m,vector<bool>(n,false));
for(int i=0;i<n;i++){
minHeap.push({-heightMap[i],0,i});
minHeap.push({-heightMap[m-1][i],m-1,i});
vis[i] = true;
vis[m-1][i] = true;
}
for(int i=1;i<m-1;i++){
minHeap.push({-heightMap[i],i,0});
minHeap.push({-heightMap[i][n-1],i,n-1});
vis[i] = true;
vis[i][n-1] = true;
}
int ans = 0;
vector<vector<int>> dirs = {{0,1},{1,0},{0,-1},{-1,0}};
while(!minHeap.empty()){
vector<int> top = minHeap.top();
minHeap.pop();
for(auto it:dirs){
int x = it + top;
int y = it + top;

if(x>=0 and y>=0 and x<m and y<n and (not vis[x][y])){
vis[x][y] = true;

if(heightMap[x][y] < heightMap[top][top]){
ans += heightMap[top][top] - heightMap[x][y];
heightMap[x][y] = heightMap[top][top];
minHeap.push({-heightMap[x][y],x,y});
}
else{
minHeap.push({-heightMap[x][y],x,y});
}
}
}
}
return ans;
}
};
```

Translate »