数组前缀和算法技巧

一、什么是数组前缀和

数组中前缀和技巧（Prefix Sum Technique）是一种常见且有用的算法技巧，特别适用于需要频繁查询数组区间和的问题。这种技巧通过创建一个额外的数组来存储原始数组中特定位置之前所有元素的和，从而在需要计算任意子数组和时能够快速得出结果；

前缀和技巧的优点在于它可以将原先需要 O(n) 时间复杂度计算的区间和问题，转化为 O(1) 时间复杂度的查询操作。这在某些问题中可以大大提高算法的效率。

二、一维数组中的前缀和

LeetCode303题，区域和检索-数组不可变，计算数组区间内元素的和

给定一个整数数组  nums，处理以下类型的多个查询:

1. 计算索引 left 和 right （包含 left 和 right）之间的 nums 元素的 和 ，其中 left <= right

实现 NumArray 类：

• NumArray(int[] nums) 使用数组 nums 初始化对象
• int sumRange(int i, int j) 返回数组 nums 中索引 left 和 right 之间的元素的 总和 ，包含 left 和 right 两点（也就是 nums[left] + nums[left + 1] + ... + nums[right] )

示例 1：

输入：
["NumArray", "sumRange", "sumRange", "sumRange"]
[[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]
输出：
[null, 1, -1, -3]

解释：
NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);
numArray.sumRange(0, 2); // return 1 ((-2) + 0 + 3)
numArray.sumRange(2, 5); // return -1 (3 + (-5) + 2 + (-1)) 
numArray.sumRange(0, 5); // return -3 ((-2) + 0 + 3 + (-5) + 2 + (-1))

 这道题暴力解法就是从left到right直接循环数组，累计和，时间复杂度是O(N)，该题的最优解是使用前缀和技巧，核心思路是定义一个新的数组preSum,preSum[i]代表nums[0...i-1]的累加和，如图所示：

如果我想求索引区间 [1, 4] 内的所有元素之和，就可以通过 preSum[5] -preSum[1] 得出。sumRange函数仅仅需要做一次减法运算，就可以算出left和right之间的元素和，时间复杂度是O(1)

具体实现代码如下：

public class NumArray {
    /**
     * 前缀和数组，pre[i]代表0到i-1的和
     */
    private int[] preSum;

    public NumArray(int[] numArray) {
        //初始化前缀和
        if(numArray!=null&&numArray.length>0){
           int len = numArray.length;
           preSum = new int[len+1];
            //计算0到i-1的累加和
            for (int i = 1; i <= len; i++) {
                preSum[i] = preSum[i-1]+numArray[i-1];
            }
        }
    }

    /**
     * 计算left 到right之间的累计和
     * @param left
     * @param right
     * @return
     */
    public int sumRange(int left, int right){
        return preSum[right+1]-preSum[left];
    }

    public static void main(String[] args) {
        int[] array = {-2, 0, 3, -5, 2, -1};
        NumArray numArray = new NumArray(array);
        int ret = numArray.sumRange(0, 5);
        System.out.println(ret);
    }

三、二维矩阵中的前缀和

leetcode 304题二维区域和检索 - 矩阵不可变，计算矩形范围内元素的总和，题目描述如下：

给定一个二维矩阵 matrix，以下类型的多个请求：

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

实现 NumMatrix 类：

• NumMatrix(int[][] matrix) 给定整数矩阵 matrix 进行初始化
• int sumRegion(int row1, int col1, int row2, int col2) 返回 左上角 (row1, col1) 、右下角 (row2, col2) 所描述的子矩阵的元素 总和 。

输入: 
["NumMatrix","sumRegion","sumRegion","sumRegion"]
[[[[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]]],[2,1,4,3],[1,1,2,2],[1,2,2,4]]
输出: 
[null, 8, 11, 12]

解释:
NumMatrix numMatrix = new NumMatrix([[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]]);
numMatrix.sumRegion(2, 1, 4, 3); // return 8 (红色矩形框的元素总和)
numMatrix.sumRegion(1, 1, 2, 2); // return 11 (绿色矩形框的元素总和)
numMatrix.sumRegion(1, 2, 2, 4); // return 12 (蓝色矩形框的元素总和)

解题思路：

1、理解题意，矩形的坐标，也是从左上角（0,0）开始的，代表的元素是3，是一个小矩形 ，根据题意，（0,0）左上角到右下角元素和是3，其他任意矩形都是从左上角延伸过来的，计算矩形坐标位置时，不能看点，要看一个面，注意计算的是起点矩形的左上角与终点矩形的右下角所包围的元素数据的总和

2、任意子矩阵元素的和可以转换成周边几个大矩阵的元素和的运算

3、利用数组前缀和思想，第一步如何初始化二维数组前缀和

定义一个二维前缀和数组preSum，preSum[i][j]代表 [0,0]到[i-1,j-1]元素的总和，根据上图计算逻辑

preSum[i,j] = preSum[i-1][j]+preSum[i][j-1]-preSum[i-1][j-1]+matrix[i-1][j-1]

4、如何计算任意子矩阵元素的和

 

 假设左上角是[row1,col1],右下角[row2,col2],由上图可知，子矩阵的元素总和计算公式如下

子矩阵元素总和=preSum[row2+1][col2+1] - preSum[row1][col2+1] - preSum[row2+1][col1]+preSum[row1][col1]

核心实现代码如下：

public class NumMatrix {
    /**
     * 定义preSum[i][j]记录matrix中子矩阵[0,0,i-1,j-1]的元素和
     */
    private int[][] preSum;

    public NumMatrix(int[][] matrix) {
        if (matrix == null) {
            return;
        }
        int row = matrix.length;
        int col = matrix[0].length;
        if (col == 0) {
            return;
        }
        //构造前缀和
        preSum = new int[row + 1][col + 1];
        for (int i = 1; i <= row; i++) {
            for (int j = 1; j <= col; j++) {
                preSum[i][j] = preSum[i][j - 1] + preSum[i - 1][j] - preSum[i - 1][j - 1] + matrix[i - 1][j - 1];
            }
        }

    }

    /**
     * 计算子矩阵【r1,c2,r2,c2]的元素和
     *
     * @param r1
     * @param c1
     * @param r2
     * @param c2
     * @return
     */
    public int sumRange(int r1, int c1, int r2, int c2) {
        //目标矩阵之后由四个相邻矩阵运算获得
        return preSum[r2 + 1][c2 + 1] - preSum[r1][c2 + 1] - preSum[r2 + 1][c1] + preSum[r1][c1];
    }

    public static void main(String[] args) {
        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}};
        NumMatrix numMatrix = new NumMatrix(matrix);
        int ret = numMatrix.sumRange(1, 2, 2, 4);
        System.out.println(ret);

    }

 以上算法的核心思想都是前缀和的思想，重点就是空间换时间，将sumRange函数的时间复杂度优化到O(1),