刷算法——前缀和与差分数组

前缀和与差分数组

前缀和数组

什么是前缀和

前缀和是一种用于快速计算数组或序列中部分元素之和的数据结构和算法技巧。对于一个数组 nums，其前缀和数组 prefix 定义为: prefix[i] = nums[0] + nums[1] + ... + nums[i]，也就是说,prefix[i] 表示从数组开头到下标 i 的所有元素之和。

前缀和的主要优点包括:

• 快速计算区间和。 如果我们想计算数组中 [i, j] 区间内的元素之和,只需要计算 prefix[j+1] - prefix[i] 即可,而不需要逐个累加区间内的元素。这样大大提高了计算效率。
• 处理差分问题。前缀和可以用来快速处理数组中元素的差分问题,比如求数组中某个区间内元素的增量。
• 空间效率高。前缀和只需要一个额外的数组存储前缀和值,空间复杂度为 O(n)。

前缀和的典型应用包括:

• 二维数组的区域和计算
• 数组区间的最大/最小值查找
• 数组中元素的累加和统计
• 差分数组的应用

⼒扣第 303 题「区域和检索 - 数组不可变」

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

计算索引 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] )

//leetcode submit region begin(Prohibit modification and deletion)
class NumArray {
// nums: 1 2 3 4 5  6  7  8  9
// sum:  0 1 3 6 10 15 21 28 36
    int[] sum;
    public NumArray(int[] nums) {
        sum = new int[nums.length+1];
        sum[0] = 0;
        //构造前缀和数组
        for (int i = 0; i < nums.length; i++) {
            //注意下标错位
            sum[i+1] = sum[i] + nums[i];
        }
    }
    public int sumRange(int left, int right) {
        return sum[right+1] - sum[left];
    }
}

/**
 * Your NumArray object will be instantiated and called as such:
 * NumArray obj = new NumArray(nums);
 * int param_1 = obj.sumRange(left,right);
 */
//leetcode submit region end(Prohibit modification and deletion)

⼒扣第 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) 所描述的子矩阵的元素 总和 。

//leetcode submit region begin(Prohibit modification and deletion)
class NumMatrix {
    int[][] sum;

    public NumMatrix(int[][] matrix) {
        sum = new int[matrix.length + 1][matrix[0].length + 1];
        sum[0][0] = 0;
        //构造前缀和二维数组
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                //两块区域的和，加该位置的值，减去两区域重合的部分
                sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] + matrix[i][j]
                        - sum[i][j];
            }
        }
    }

    public int sumRegion(int row1, int col1, int row2, int col2) {
        //大块区域减去两小块区域，再加两小块中重合的一小块
        return sum[row2 + 1][col2 + 1] - sum[row1][col2 + 1]
                - sum[row2 + 1][col1] + sum[row1][col1];
    }
}

/**
 * Your NumMatrix object will be instantiated and called as such:
 * NumMatrix obj = new NumMatrix(matrix);
 * int param_1 = obj.sumRegion(row1,col1,row2,col2);
 */
//leetcode submit region end(Prohibit modification and deletion)

差分数组

差分数组是一种用来快速处理数组区间修改问题的数据结构。它与前缀和的思路类似,但是处理的对象不同。

对于一个数组 nums，其差分数组 diff 定义为: diff[i] = nums[i] - nums[i-1]

其中 diff[0] = nums[0]。

也就是说,差分数组中的每个元素 diff[i] 表示原数组中相邻两个元素之间的差值。

差分数组的主要特点如下:

• 快速区间修改: 如果我们想把数组 nums 中 [i, j] 区间内的所有元素都增加 delta，只需要将 diff[i] 增加 delta，diff[j+1] 减少 delta。这样就可以在 O(1) 的时间内完成区间修改。
• 快速区间查询: 如果我们想查询数组 nums 中 [i, j] 区间内元素的和,只需要计算 sum(diff[i], diff[i+1], …, diff[j])，即可在 O(j-i+1) 的时间内完成。
• 空间效率高: 差分数组只需要一个额外的数组存储差分值,空间复杂度为 O(n)。

⼒扣第 1109 题「航班预订统计」

这里有 n 个航班，它们分别从 1 到 n 进行编号。

有一份航班预订表 bookings ，表中第 i 条预订记录 bookings[i] = [firsti, lasti, seatsi] 意味着在从 firsti 到 lasti （包含 firsti 和 lasti ）的 每个航班 上预订了 seatsi 个座位。

请你返回一个长度为 n 的数组 answer，里面的元素是每个航班预定的座位总数。

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    int[] diff;
    public int[] corpFlightBookings(int[][] bookings, int n) {
        int[] arr = new int[n];
        difference(arr);
        for(int[] booking:bookings){
            //转换时使用数组下标
            increment(booking[0]-1,booking[1]-1,booking[2]);
        }
        return result();
    }
    //差分数组构造
    public void difference(int[] nums) {
        //当传入的 nums 数组为空时,会出现数组下标越界的问题,在长度为 0 的情况下直接返回
        if (nums.length == 0) {
            return;
        }
        diff = new int[nums.length];
        diff[0] = nums[0];
        for (int i = 1; i < nums.length; i++) {
            diff[i] = nums[i] - nums[i - 1];
        }
    }

    //区间内的计算
    public void increment(int i, int j, int val) {
        diff[i] += val;
        //防止j为最后一个值时，数组越界
        if (j + 1 < diff.length)
            diff[j + 1] -= val;
    }

    //返回结果
    public int[] result() {
        int[] res = new int[diff.length];
        res[0] = diff[0];
        //根据差分数组，原数组，得到原数组给定区间加上某个值之后的结果
        for (int i = 1; i < diff.length; i++) {
            res[i] = res[i - 1] + diff[i];
        }
        return res;
    }
}
//leetcode submit region end(Prohibit modification and deletion)