接雨水系列题目

接雨水系列题目

leetcode上的两道接雨水的题目，一道是基础版的，另一道是进阶版的
42. 接雨水
407. 接雨水 II
下面来看具体题目

42. 接雨水

题目

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。

思路

对于每一个位置，计算其能存的最大水量，然后对所有位置的水量求和。对于每一个位置，求出其左边的最高边界，和其右边的最高边界，然后取其中最小的作为边界（木桶短板问题），然后计算所存的水量。

在这种思路下，有三种具体的实施方法

1. 暴力方法，两层循环，时间复杂度O(N^2)，空间复杂度O（1），代码省略
2. 使用两个数组，空间换时间，时间复杂度O(N),空间复杂度O(N)。用一个数组L，L[i]表示i左边最高边界的高度（可以包含自身），数据R，R[i]表示i右边最高的边界高度（可以包括自身），然后计算水量，代码如下：

public int trap(int[] height) {
        int n = height.length;
        int L[] = new int[n];
        int R[]  = new int[n];

        for(int i=0;i<n;i++){
            if(i==0){
                L[i] = height[0];
            }else{
                L[i] = Math.max(L[i-1],height[i]);
            }
        }
        for(int i=n-1;i>=0;i--){
            if(i==n-1){
                R[i] = height[i];
            }else{
                R[i]  = Math.max(height[i],R[i+1]);
            }
        }

        int sum =0 ;
        for(int i=0;i<n;i++){
            int m = Math.min(L[i],R[i]);
            sum = sum+(m-height[i]);
        }

        return sum;
    }

3. 不需要使用额外的空间，使用双指针策略。使用两个变量L_max和R_max表示左右边界，最开始L_max初始化为0位置的元素，R_max初始化为n-1位置的元素。
   定义双指针l和r，如果L_max<R_max，则遍历左边的元素，计算l位置的存水量，计算方式为s = Math.max(L_max-l,0)，因为此时，l位置的最高左边界已经找到了(是L_max)，虽然其最高右边界没找到，但是已知的右边界已经比最高左边界要大了，所以没必要找最高右边界了。然后如果l位置的元素大于L_max位置的元素，则用l位置更新L_max；若L_max>=R_max，同理。
   时间复杂度为O（N)，空间复杂度为O(1)。代码如下：

    public int trap(int[] height) {
        int n = height.length;
        if(n==0){
            return 0;
        }
        int max_l = height[0];
        int max_r = height[n-1];

        int l = 1;
        int r = n-2;
        int sum  =0 ;
        while(l<=r){
            if(max_l<max_r){
                sum = sum+Math.max(max_l-height[l],0);
                if(max_l<height[l]){
                    max_l = height[l];
                }
                l++;
            }else{
                sum = sum+Math.max(max_r-height[r],0);
                if(max_r<height[r]){
                    max_r = height[r];
                }
                r--;
            }
        }
        return sum;
    }

407. 接雨水 II

题目

给你一个 m x n 的矩阵，其中的值均为非负整数，代表二维高度图每个单元的高度，请计算图中形状最多能接多少体积的雨水。

示例：

给出如下 3x6 的高度图:
[
[1,4,3,1,3,2],
[3,2,1,3,2,4],
[2,3,3,2,3,1]
]

返回 4 。

思路

这道题是上面那道题的三维版本。和上面那道题的处理方法不同。需要使用最小堆来进行宽度优先搜索。

首先定义一个数据结构<value,row,col>分别表示某个位置的高度和横纵坐标。然后将矩阵四周的元素以三元组的形式加入到最小堆中，之后取出堆中的第一个元素，以该元素的value值作为max_v，计算其上下左右的四个邻居元素的存水量，计算方式如下s = Math.max(max_v-v,0)，v分别表示其四个邻居的高度，然后将它们加入到堆中。之后再取出堆中第一个元素，对max_v进行更新，然后继续计算其邻居的存水量，直到堆为空。这里要注意，不能重复加入。

代码如下

    public int trapRainWater(int[][] heightMap) {
		//定义一个堆，并指定其比较器
		//其实也可以不用创建一个对象G，使用int[]数组表示三元组也可以
        PriorityQueue<G> heap = new PriorityQueue<>(new Comparator<G>() {
            @Override
            public int compare(G o1, G o2) {
                return o1.value-o2.value;
            }
        });
		
        int n = heightMap.length;
        int m = heightMap[0].length;
        //用于指示每个位置的元素是否已经加入到堆中
        boolean[][] visited = new boolean[n][m];
        //加入四周的元素
        for(int i=0;i<n;i++){
            heap.add(new G(heightMap[i][0],i,0));
            heap.add(new G(heightMap[i][m-1],i,m-1));
            visited[i][0]= true;
            visited[i][m-1]= true;
        }
        for(int i=0;i<m;i++){
            heap.add(new G(heightMap[0][i],0,i));
            heap.add(new G(heightMap[n-1][i],n-1,i));
            visited[0][i] = true;
            visited[n-1][i] = true;
        }

        int sum=  0;
        int max = 0;
        //迭代计算，直到堆为空
        while(!heap.isEmpty()){
            G tmp= heap.poll();
            max = Math.max(max,tmp.value);
            if(tmp.row>0 && !visited[tmp.row-1][tmp.col]){
                sum = sum+Math.max(max-heightMap[tmp.row-1][tmp.col],0);
                heap.add(new G(heightMap[tmp.row-1][tmp.col],tmp.row-1,tmp.col));
                visited[tmp.row-1][tmp.col]  =true;
            }
            if(tmp.row<n-1 && !visited[tmp.row+1][tmp.col]){
                sum = sum+Math.max(max-heightMap[tmp.row+1][tmp.col],0);
                heap.add(new G(heightMap[tmp.row+1][tmp.col],tmp.row+1,tmp.col));
                visited[tmp.row+1][tmp.col]  =true;
            }

            if(tmp.col>0 && !visited[tmp.row][tmp.col-1]){
                sum = sum+Math.max(max-heightMap[tmp.row][tmp.col-1],0);
                heap.add(new G(heightMap[tmp.row][tmp.col-1],tmp.row,tmp.col-1));
                visited[tmp.row][tmp.col-1]  =true;
            }
            if(tmp.col<m-1 && !visited[tmp.row][tmp.col+1]){
                sum = sum+Math.max(max-heightMap[tmp.row][tmp.col+1],0);
                heap.add(new G(heightMap[tmp.row][tmp.col+1],tmp.row,tmp.col+1));
                visited[tmp.row][tmp.col+1]  =true;
            }
        }

        return sum;
    }

    private class G{
        int value;
        int row;
        int col;
        public G(int value, int row, int col) {
            this.value = value;
            this.row = row;
            this.col = col;
        }
    }