前缀和主要适用的场景是原始数组不会被修改的情况下，频繁查询某个区间的累加和。

class PrefixSum {
    // 前缀和数组
    private int[] prefix;
    /* 输入一个数组，构造前缀和 */
    public PrefixSum(int[] nums) {
        prefix = new int[nums.length + 1];
        // 计算 nums 的累加和
        for (int i = 1; i < prefix.length; i++) {
            prefix[i] = prefix[i - 1] + nums[i - 1];
        }
    }
    /* 查询闭区间 [i, j] 的累加和 */
    public int query(int i, int j) {
        return prefix[j + 1] - prefix[i];
    }
}

差分数组的主要适用场景是频繁对原始数组的某个区间的元素进行增减。
这里就需要差分数组的技巧，类似前缀和技巧构造的 prefix 数组，我们先对 nums 数组构造一个 diff 差分数组，diff[i] 就是 nums[i] 和 nums[i-1] 之差：

int[] diff = new int[nums.length];
// 构造差分数组
diff[0] = nums[0];
for (int i = 1; i < nums.length; i++) {
    diff[i] = nums[i] - nums[i - 1];
}

根据公式，可以通过 diff 查分数组反推出原始数组 nums：

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];
}

这样构造差分数组 diff，就可以快速进行区间增减的操作，如果你想对区间 nums[i..j] 的元素全部加 3，那么只需要让 diff[i] += 3，然后再让 diff[j+1] -= 3 即可：

原理是这样的，回想diff数组反推nums数组的过程，diff[i] += 3 意味着给 nums[i..] 的所有元素都加了3，例如给上面的图中 diff[i] 加3变成0，那么nums[i] 也要加3成为8，后面 num[i+1] 为了保持diff[i+1]不变，需要也加3，所以diff[i] += 3 意味着给 nums[i..] 的所有元素都加了3。
然后 diff[j+1] -= 3 意味着对于 nums[j+1..] 所有元素再减3，那么综合起来，就是对 nums[i..j] 中的所有元素都加3了。
现在我们把差分数组抽象成一个类，包含 increment 方法和 result 方法：

差分数组工具类

这里需要注意 increment函数中的if语句，当 j + 1 >= diff.length 时，说明是对nums[i..]所有的元素进行修改，不需要再给diff数组减val了：

// 差分数组工具类
class Difference {
    // 差分数组
    private int[] diff;
    /* 输入一个初始数组，区间操作将在这个数组上进行 */
    public Difference(int[] nums) {
        assert nums.length > 0;
        diff = new int[nums.length];
        // 根据初始数组构造差分数组
        diff[0] = nums[0];
        for (int i = 1; i < nums.length; i++) {
            diff[i] = nums[i] - nums[i - 1];
        }
    }
    /* 给闭区间 [i, j] 增加 val（可以是负数）*/
    public void increment(int i, int j, int val) {
        diff[i] += val;
        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;
    }
}

370. 区间加法🔒

用 Difference类就可以解决：

int[] getModifiedArray(int length, int[][] updates) {
    // nums 初始化为全 0
    int[] nums = new int[length];
    // 构造差分解法
    Difference df = new Difference(nums);
    for (int[] update : updates) {
        int i = update[0];
        int j = update[1];
        int val = update[2];
        df.increment(i, j, val);
    }
    return df.result();
}

1109. 航班预订统计

这道题，表面看起来很复杂，题目读明白才知道本质是一道差分数组的题。这道题需要注意的是，输入中给出的索引需要减1，因为输入里是从1开始算的。

int[] corpFlightBookings(int[][] bookings, int n) {
    // nums 初始化为全 0
    int[] nums = new int[n];
    // 构造差分解法
    Difference df = new Difference(nums);
    for (int[] booking : bookings) {
        // 注意转成数组索引要减一哦
        int i = booking[0] - 1;
        int j = booking[1] - 1;
        int val = booking[2];
        // 对区间 nums[i..j] 增加 val
        df.increment(i, j, val);
    }
    // 返回最终的结果数组
    return df.result();
}

1094. 拼车

这道题也是用差分数组，但是差分数组的长度（车站的个数）没有给出，所以取数据的取值范围1001.

boolean carPooling(int[][] trips, int capacity) {
    // 最多有 1001 个车站
    int[] nums = new int[1001];
    // 构造差分解法
    Difference df = new Difference(nums);

    for (int[] trip : trips) {
        // 乘客数量
        int val = trip[0];
        // 第 trip[1] 站乘客上车
        int i = trip[1];
        // 第 trip[2] 站乘客已经下车，
        // 即乘客在车上的区间是 [trip[1], trip[2] - 1]
        int j = trip[2] - 1;
        // 进行区间操作
        df.increment(i, j, val);
    }

    int[] res = df.result();

    // 客车自始至终都不应该超载
    for (int i = 0; i < res.length; i++) {
        if (capacity < res[i]) {
            return false;
        }
    }
    return true;
}

Leetcode刷题记录

差分数组(370、1109、1094)

差分数组工具类

370. 区间加法🔒

1109. 航班预订统计

1094. 拼车