差分数组。

前言

提示：这里可以添加本文要记录的大概内容：

差分数组适用于频繁对原始数组的某个区间的元素进行增减；

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、差分数组

给一个数组nums，然后要求给区间nums[2…6]全部加1，再给nums[3…9]全部减3，再给nums[0…4]全部加2，再给…
然后询问最后的nums的数组值是多少。
这里就需要差分数组的技巧，有点类似于前缀和技巧构造的preSum,先对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[j+1]-=3又意味着对于nums[j+1…]所有元素再减3，那综合起来，对nums[i…j]中的所有元素都加3了。

现在我们把差分数组抽象成一个类，包含increment方法和result方法：

// 差分数组⼯具类
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;
 }
}

这里注意increment方法中的语句

public void increment(int i, int j, int val) {
 diff[i] += val;
if (j + 1 < diff.length) {
 diff[j + 1] -= val;
 }
}

当 j+1 >= diff.length 时，说明是对 nums[i] 及以后的整个数组都进⾏修改，那么就不需要再给 diff数组减 val 了。

二、力扣1094拼车

1.分析

联想到差分数组技巧了：trips[i] 代表着一组区间操作，旅客的上车和下车就相当于数组的区间加减；只要结果数组中的元素都小于 capacity，就说明可以不超载运输所有旅客。

这题还有一个细节，一批乘客从站点 trip[1] 上车，到站点 trip[2] 下车，呆在车上的站点应该是 [trip[1], trip[2] - 1]，这是需要被操作的索引区间。
代码如下：

class Solution {
public:
    bool carPooling(vector<vector<int>>& trips, int capacity) {
        // 最多有 1000 个车站
        vector<int> nums(1001, 0);
        // 构造差分解法
        Difference df(nums);

        for (const auto& 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);
        }

        vector<int> res = df.result();

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

    // 差分数组工具类
    class Difference {
        // 差分数组
        vector<int> diff;

        /* 输入一个初始数组，区间操作将在这个数组上进行 */
        public:
        Difference(vector<int>& nums) {
            diff.resize(nums.size());
            // 根据初始数组构造差分数组
            diff[0] = nums[0];
            for (int i = 1; i < nums.size(); i++) {
                diff[i] = nums[i] - nums[i - 1];
            }
        }

        /* 给闭区间 [i, j] 增加 val（可以是负数）*/
        void increment(int i, int j, int val) {
            diff[i] += val;
            if (j + 1 < diff.size()) {
                diff[j + 1] -= val;
            }
        }

        /* 返回结果数组 */
        vector<int> result() {
            vector<int> res(diff.size());
            // 根据差分数组构造结果数组
            res[0] = diff[0];
            for (int i = 1; i < diff.size(); i++) {
                res[i] = res[i - 1] + diff[i];
            }
            return res;
        }
    };
};