Trapping Rain Water I && II

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.

The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. Thanks Marcos for contributing this image!

Example:

Input: [0,1,0,2,1,0,1,3,2,1,2,1]
Output: 6

Analysis:

We first find out the max height in the array, then we start from the leftmost bar which is considered as the wall of the container. If there is a bar whose height is less than the wall, water will be saved above that bar. We do the same operation from rightmost to the highest bar position.

 public class Solution {
     public int trap(int[] height) {
         if (height == null || height.length <= ) return ;
         int maxIndex = ;
         for (int i = ; i < height.length; i++) {
             if (height[i] > height[maxIndex]) {
                 maxIndex = i;
             }
         }
         int leftMax = height[];
         int total = ;
         for (int i = ; i < maxIndex; i++) {
             if (height[i] < leftMax) {
                 total += (leftMax - height[i]);
             } else {
                 leftMax = height[i];
             }
         }
         int rightMax = height[height.length - ];
         for (int i = height.length - ; i > maxIndex; i--) {
             if (height[i] < rightMax) {
                 total += (rightMax - height[i]);
             } else {
                 rightMax = height[i];
             }
         }
         return total;
     }
 }

Trapping Rain Water II

Given an m x n matrix of positive integers representing the height of each unit cell in a 2D elevation map, compute the volume of water it is able to trap after raining.

Note:

Both m and n are less than 110. The height of each unit cell is greater than 0 and is less than 20,000.

Example:

Given the following 3x6 height map:
[
  [1,4,3,1,3,2],
  [3,2,1,3,2,4],
  [2,3,3,2,3,1]
]

Return 4.

The above image represents the elevation map [[1,4,3,1,3,2],[3,2,1,3,2,4],[2,3,3,2,3,1]] before the rain.

After the rain, water is trapped between the blocks. The total volume of water trapped is 4.

分析：

从四周出发，选取最低点（木桶原理），然后选取周围没有被visited的点。找到更低的点，则把当前点和低点的差值作为可以装水的量，注意，在加入新的点的时候，那个点的高度应该使用当前点的高度，这样我们就不用倒着回去找最高点了。

 class Solution {
     public int trapRainWater(int[][] heights) {
         if (heights == null || heights.length ==  || heights[].length == ) return ;

         PriorityQueue<Cell> queue = new PriorityQueue<>(, (cell1, cell2) ->  cell1.height - cell2.height);
         int row = heights.length, col = heights[].length;
         boolean[][] visited = new boolean[row][col];

         // add border cells to the queue.
         for (int i = ; i < row; i++) {
             visited[i][] = true;
             visited[i][col - ] = true;
             queue.offer(new Cell(i, , heights[i][]));
             queue.offer(new Cell(i, col - , heights[i][col - ]));
         }

         for (int i = ; i < col; i++) {
             visited[][i] = true;
             visited[row - ][i] = true;
             queue.offer(new Cell(, i, heights[][i]));
             queue.offer(new Cell(row - , i, heights[row - ][i]));
         }

         // from the borders, pick the shortest cell visited and check its neighbors:
         // if the neighbor is shorter, collect the water it can trap and update its height as its height plus the water trapped
        // add all its neighbors to the queue.
         int[][] dirs = new int[][]{{-, }, {, }, {, -}, {, }};
         int res = ;
         while (!queue.isEmpty()) {
             Cell cell = queue.poll();
             for (int[] dir : dirs) {
                 int neighbor_row = cell.row + dir[];
                 int neighbor_col = cell.col + dir[];
                 if (neighbor_row >=  && neighbor_row < row && neighbor_col >=  && neighbor_col < col && !visited[neighbor_row][neighbor_col]) {
                     visited[neighbor_row][neighbor_col] = true;
                     res += Math.max(, cell.height - heights[neighbor_row][neighbor_col]);
                     queue.offer(new Cell(neighbor_row, neighbor_col, Math.max(heights[neighbor_row][neighbor_col], cell.height)));
                 }
             }
         }
         return res;
     }
 }

 class Cell {
     int row;
     int col;
     int height;
     public Cell(int row, int col, int height) {
         this.row = row;
         this.col = col;
         this.height = height;
     }
 }