LeetCode：二维区域和检索-矩阵不可变

题目

给定一个二维矩阵，计算其子矩形范围内元素的总和，该子矩阵的左上角为 (row1, col1) ，右下角为 (row2, col2) 。

上图子矩阵左上角 (row1, col1) = (2, 1) ，右下角(row2, col2) = (4, 3)，该子矩形内元素的总和为 8。

示例：

给定 matrix = [
[3, 0, 1, 4, 2],
[5, 6, 3, 2, 1],
[1, 2, 0, 1, 5],
[4, 1, 0, 1, 7],
[1, 0, 3, 0, 5]
]

sumRegion(2, 1, 4, 3) -> 8
sumRegion(1, 1, 2, 2) -> 11
sumRegion(1, 2, 2, 4) -> 12

提示：

你可以假设矩阵不可变。
会多次调用 sumRegion 方法。
你可以假设 row1 ≤ row2 且 col1 ≤ col2 。

【来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/range-sum-query-2d-immutable】

题目分析

题目容易理解，首先给定一个不可变的矩阵，就题目所给矩阵而言，要解决sumRegion(2, 1, 4, 3) -> 8，我们先把矩阵放于Excel中，如下图：

即为求图中蓝色底单元格中数据和：2+0+1+1+0+1+0+3+0=8

解法一：常规暴力法

不考虑效率高低与空数组传入问题，循规蹈矩利用for循环解出最终答案，上代码：

public class NumMatrix {
    int[][] nums;

    public NumMatrix(int[][] matrix) {
        int rowCount = matrix.length;
        int colCount = matrix[0].length;
        nums = new int[rowCount][colCount]; //直接复制数组
        for(int i = 0;i<rowCount;i++){
            for(int k = 0;k<colCount;k++){
                nums[i][k] = matrix[i][k];
            }
        }
    }

    public int sumRegion(int row1, int col1, int row2, int col2) {
        int sum = 0;
        for(int i = row1;i<=row2;i++){
            for(int k = col1;k<=col2;k++){
                sum += nums[i][k];
            }
        }
        return sum;
    }
  }

测试代码：

    @Test
    public void Test(){
        int[][] matrix = {{3,0,1,4,2},{5,6,3,2,1},{1,2,0,1,5},{4,1,0,1,7},{1,0,3,0,5}};
        long start = System.nanoTime();
        NumMatrix numMatrix = new NumMatrix(matrix);
        System.out.println(numMatrix.sumRegion(2,1,4,3));
        long end = System.nanoTime();
        System.out.println("Time：" + (end-start));
    }

输出：
8
Time：422700

解法二：按行前缀和

1.首先解法一思路并不严谨，没有考虑空数组传入问题
2.暴力解法仅限用与临时调用时给出结果，若所求区域范围为m * n，则其复杂度为O（m * n），若多次调用复杂度太高，显然不可取
3.借鉴力扣官方给出的一维数组区域和检索的前缀和解法，尝试将计算复杂度降为O（1）

我们先来看下官方给出的一维数组的前缀和解法：

class NumArray {
    int[] sums;

    public NumArray(int[] nums) {
        int n = nums.length;
        sums = new int[n + 1];
        for (int i = 0; i < n; i++) {
            sums[i + 1] = sums[i] + nums[i];
        }
    }
    
    public int sumRange(int i, int j) {
        return sums[j + 1] - sums[i];
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/range-sum-query-immutable/solution/qu-yu-he-jian-suo-shu-zu-bu-ke-bian-by-l-px41/
来源：力扣（LeetCode）

其实官方是把计算的过程放到了构造NumArray对象的时候，首位增加一位0，此后sums数组第 i 项就等于sums[ i-1 ] + nums[ i-1 ]了，图示如下：

这样一来，要想求一维数组某个范围内的元素和就转换为新数组中两元素之差了，如下图：

于是，二维数组区域求值可以转换为按每行先求前缀和，其次再将各行所得结果相加便为方形区域内元素和：

这个方法的代码就不再粘贴了，返回时计算仍有复杂度O（row2 - row1+1）

解法三：行列前缀和

搞懂了解法二，那么解法三也容易想出，那就是在按行求完前缀和后再按列求前缀和，示例图如下：

这样一来，无论求二维数组什么区域（合法）的数据和都可转换为四个已知数据的加减运算，复杂度降为O（1），代码如下：

public class NumMatrix {
    int[][] nums;

    public NumMatrix(int[][] matrix) {
        if(matrix==null||matrix.length==0||(matrix.length==1&&matrix[0].length==0)){}//判断数组为空或为{{}}
        else {
            int rowCount = matrix.length;
            int colCount = matrix[0].length;
            nums = new int[rowCount+1][colCount+1]; //增加一行和一列辅助位
            for(int i = 1;i<=rowCount;i++){  //按行求前缀和
                for(int k = 1;k<=colCount;k++){
                    nums[i][k] = matrix[i-1][k-1] + nums[i][k-1];
                }
            }
            for(int i = 1;i<=rowCount;i++){  //按列求前缀和
                for(int k = 1;k<=colCount;k++){
                    nums[i][k] = nums[i][k] + nums[i-1][k];
                }
            }

        }
    }

    public int sumRegion(int row1, int col1, int row2, int col2) {
        return (nums[row2+1][col2+1]-nums[row1][col2+1])-(nums[row2+1][col1]-nums[row1][col1]);
    }
}

测试代码：

	@Test
    public void Test(){
        int[][] matrix = {{3,0,1,4,2},{5,6,3,2,1},{1,2,0,1,5},{4,1,0,1,7},{1,0,3,0,5}};
        long start = System.nanoTime();
        NumMatrix numMatrix = new NumMatrix(matrix);
        System.out.println(numMatrix.sumRegion(2,1,4,3));
        long end = System.nanoTime();
        System.out.println("Time：" + (end-start));
    }

输出：
8
Time：422800

解法三的优化与测评

在构造NumMatrix对象时，我们在先按行求前缀和的基础上又按列求得行列前缀和，使用了两次双层for循环。事实上，只利用一次双层for循环即可实现以上效果，图示如下：

搞清楚了原理，我们就可以上代码了：

public class NumMatrix {
    int[][] nums;

    public NumMatrix(int[][] matrix) {
        if(matrix==null||matrix.length==0||(matrix.length==1&&matrix[0].length==0)){}//判断数组为空或为{{}}
        else {
            int rowCount = matrix.length;
            int colCount = matrix[0].length;
            nums = new int[rowCount+1][colCount+1]; //增加一行和一列辅助位
            for(int i = 1;i<=rowCount;i++){
                for(int k = 1;k<=colCount;k++){
                    nums[i][k] = nums[i][k-1] + nums[i-1][k] + matrix[i-1][k-1] - nums[i-1][k-1];
                }
            }
        }
    }

    public int sumRegion(int row1, int col1, int row2, int col2) {
        return (nums[row2+1][col2+1]-nums[row1][col2+1])-(nums[row2+1][col1]-nums[row1][col1]);
    }
}

测试代码：

    @Test
    public void Test(){
        int[][] matrix = {{3,0,1,4,2},{5,6,3,2,1},{1,2,0,1,5},{4,1,0,1,7},{1,0,3,0,5}};
        long start = System.nanoTime();
        NumMatrix numMatrix = new NumMatrix(matrix);
        System.out.println(numMatrix.sumRegion(2,1,4,3));
        long end = System.nanoTime();
        System.out.println("Time：" + (end-start));
    }

输出：
8
Time：341500

接下来我们分别调用10000次方法一的暴力解法与优化后的方法三，看看运行时间的差距，测试代码：

    @Test
    public void Test(){
        int[][] matrix = {{3,0,1,4,2},{5,6,3,2,1},{1,2,0,1,5},{4,1,0,1,7},{1,0,3,0,5}};
        long start = System.currentTimeMillis();
        NumMatrix numMatrix = new NumMatrix(matrix);
        for(int i = 0;i<10000;i++){
        System.out.print(numMatrix.sumRegion(0,0,4,4));}
        long end = System.currentTimeMillis();
        System.out.println();
        System.out.println("Time：" + (end-start) + "ms");
    }

结果：
方法一
方法三
其实大部分运行时间是在println上了，而且每次运行的话最终显示的ms数也不太稳定，大家有兴趣可以自己测试一下。

解题心得

这次的解法是在查看官方解答之前已经提交通过了的，刚开始也不确定是否可以继续沿用一维数组的方法，经过一些计算之后觉得方法可行就编出来了。昨天在写一维数组区域检索的时候看完官方解答让我茅塞顿开，可能这就是动态规划的魅力吧，照这个趋势看看明天官方会不会再搞出来个三维区域检索出来吧。

整个测试过程总结起来还是那俩字儿