前缀和 - 标签 - 豆浆小屋

差分数组知识点

Tue, 04 Aug 2026 00:00:00 +0000

差分数组 (Difference Array)

1 核心思想

差分数组是前缀和的逆运算，适用于频繁对数组某个区间进行增减操作的场景。

暴力做法：每次区间修改 O(n)，m 次操作 O(n*m)
差分数组：每次修改 O(1)，最后还原 O(n)，总复杂度 O(n + m)

2 一、基本原理

2.1 构造差分数组

1

diff[i] = nums[i] - nums[i-1]

索引	0	1	2	3	4
nums	2	5	1	4	3
diff	2	3	-4	3	-1

2.2 区间增减操作

对区间 [i, j] 的所有元素 +val：

1
2


diff[i] += val;
diff[j + 1] -= val;   // 注意边界：j+1 不能越界

原理：

diff[i] += val → 从 i 开始，后面所有元素都加了 val
diff[j+1] -= val → 从 j+1 开始，抵消前面的增量
综合效果：只有 [i, j] 区间加了 val

2.3 还原结果数组

对 diff 做一次前缀和，得到最终的 nums：

1
2
3
4


res[0] = diff[0];
for (int i = 1; i < n; i++) {
    res[i] = res[i - 1] + diff[i];
}

3 二、模板代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


class Difference {
private:
    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;
        }
        // j+1 越界说明加到末尾，不用减
    }

    // 返回最终结果数组
    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;
    }
};

4 三、常见题型

4.1 题型 1：区间加法（直接套用）

例题： 假设你有一个长度为 n 的数组，初始都为 0。给你 k 个更新操作，每个操作表示对区间 [start, end] 增加 inc。返回最终数组。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


vector<int> getModifiedArray(int n, vector<vector<int>>& updates) {
    vector<int> diff(n, 0);
    for (auto& op : updates) {
        int s = op[0], e = op[1], val = op[2];
        diff[s] += val;
        if (e + 1 < n) diff[e + 1] -= val;
    }
    // 还原
    vector<int> res(n);
    res[0] = diff[0];
    for (int i = 1; i < n; i++) {
        res[i] = res[i - 1] + diff[i];
    }
    return res;
}

4.2 题型 2：航班预订统计

LeetCode 1109： 这里有 n 个航班，预订记录 [i, j, k] 表示从 i 到 j 航班增加 k 个座位。返回每个航班的最终预订数。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


vector<int> corpFlightBookings(vector<vector<int>>& bookings, int n) {
    vector<int> diff(n, 0);
    for (auto& b : bookings) {
        int first = b[0] - 1;   // 注意题目是 1-based
        int last = b[1] - 1;
        int seats = b[2];
        diff[first] += seats;
        if (last + 1 < n) diff[last + 1] -= seats;
    }
    // 前缀和还原
    for (int i = 1; i < n; i++) {
        diff[i] += diff[i - 1];
    }
    return diff;
}

4.3 题型 3：拼车问题

LeetCode 1094： 车上有 capacity 个空位，乘客上下车，问能不能全部装下。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


bool carPooling(vector<vector<int>>& trips, int capacity) {
    vector<int> diff(1001, 0);  // 站点最多 1000
    for (auto& t : trips) {
        int num = t[0], from = t[1], to = t[2];
        diff[from] += num;
        diff[to] -= num;   // 到 to 站下车，不用 to+1
    }

    int cur = 0;
    for (int x : diff) {
        cur += x;
        if (cur > capacity) return false;
    }
    return true;
}

5 四、二维差分

对于矩阵的区间加减，也有二维差分：

1
2
3
4
5
6
7


// 对矩形 (x1,y1) ~ (x2,y2) 加 val
diff[x1][y1] += val;
diff[x2 + 1][y1] -= val;
diff[x1][y2 + 1] -= val;
diff[x2 + 1][y2 + 1] += val;

// 最后做二维前缀和还原

6 五、经典题目

题目	类型	难度
370. 区间加法	模板题	中等
1109. 航班预订统计	模板题	中等
1094. 拼车	差分 + 扫描线	中等
253. 会议室 II	差分思想	中等
731. 我的日程安排表 II	差分 + TreeMap	中等
598. 范围求和 II	二维差分变种	简单

7 六、解题技巧

判断要不要用差分： 题目出现「多次区间加减，最后求结果」，直接想差分
注意下标： 题目给的是 1-based 还是 0-based，要转换
边界处理： j+1 越界时不用减，说明加到末尾
不需要还原整个数组： 比如拼车问题，边累加边判断即可
数据范围大时： 用 map 存离散的差分点（扫描线思想）

前缀和知识点

Tue, 04 Aug 2026 00:00:00 +0000

前缀和 (Prefix Sum)

1 核心思想

前缀和是一种预处理技术，通过预先计算数组的前缀和，将区间求和查询从 $O(n)$ 优化到 $O(1)$。

定义： prefix[i] 表示数组前 i 个元素的和（从下标 1 开始）。

$$ \text{prefix}[i] = \sum_{k=0}^{i-1} \text{nums}[k] $$

区间和公式： $\text{sum}(l, r) = \text{prefix}[r+1] - \text{prefix}[l]$

2 一维前缀和模板

1
2
3
4
5
6
7
8


// 构建前缀和数组（长度 n+1，prefix[0] = 0）
vector<int> prefix(n + 1, 0);
for (int i = 0; i < n; i++) {
    prefix[i + 1] = prefix[i] + nums[i];
}

// 查询 [l, r] 的区间和（闭区间）
int rangeSum = prefix[r + 1] - prefix[l];

3 二维前缀和模板

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 构建二维前缀和
vector<vector<int>> prefix(m + 1, vector<int>(n + 1, 0));
for (int i = 1; i <= m; i++) {
    for (int j = 1; j <= n; j++) {
        prefix[i][j] = prefix[i-1][j] + prefix[i][j-1]
                     - prefix[i-1][j-1] + matrix[i-1][j-1];
    }
}

// 查询 (r1,c1) 到 (r2,c2) 的子矩阵和
int sum = prefix[r2+1][c2+1] - prefix[r1][c2+1]
        - prefix[r2+1][c1] + prefix[r1][c1];

4 常见变形

4.1 1. 前缀和 + 哈希表（求子数组和为 k 的个数）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 核心：prefix[j] - prefix[i] = k  →  prefix[i] = prefix[j] - k
int subarraySum(vector<int>& nums, int k) {
    unordered_map<int, int> cnt;
    cnt[0] = 1;  // 空前缀
    int pre = 0, ans = 0;
    for (int x : nums) {
        pre += x;
        if (cnt.count(pre - k)) ans += cnt[pre - k];
        cnt[pre]++;
    }
    return ans;
}

4.2 2. 前缀和求最长/最短子数组

求 和为 k 的最长子数组长度 → 哈希表存前缀和首次出现的下标
求 和 ≥ k 的最短子数组 → 单调队列 + 前缀和

4.3 3. 差分数组（前缀和的逆运算）

1
2
3
4


// 区间增减：对 [l, r] 所有元素 +val
diff[l] += val;
diff[r + 1] -= val;
// 最后做前缀和还原

4.4 4. 前缀异或 / 前缀积

前缀异或：preXor[i+1] = preXor[i] ^ nums[i]
区间异或和：preXor[r+1] ^ preXor[l]

5 经典题目

题目	关键点	笔记
560. 和为 K 的子数组	前缀和 + 哈希表计数	题解
304. 二维区域和检索	二维前缀和模板	—
525. 连续数组	0 变 -1，前缀和 + 哈希表	题解
974. 和可被 K 整除的子数组	同余定理：`(pre % k + k) % k`	—
238. 除自身以外数组的乘积	前缀积 + 后缀积	—
437. 路径总和 III	树上前缀和 + 回溯	—
862. 和至少为 K 的最短子数组	前缀和 + 单调队列	—
1124. 表现良好的最长时间段	前缀和 + 贪心	—
1314. 矩阵区域和	二维前缀和模板	—

6 注意事项

前缀和数组长度通常是 n+1，prefix[0] = 0，方便处理从头开始的区间
哈希表初始化 cnt[0] = 1（或 pos[0] = -1），表示空前缀
元素可能为负数时，前缀和不单调，不能用滑动窗口，要用哈希表
取模问题注意负数处理：(x % k + k) % k
二维前缀和注意容斥原理：加两次左上角

Q209 长度最小的子数组

Sat, 01 Aug 2026 00:00:00 +0000

题目：给定一个含有 n 个正整数的数组和一个正整数 s，找出该数组中满足其和 ≥ s 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

1 我的想法

我看到这个问题，首先发现它是连续的、并且要求区间大小，会想到用前缀和操作——前缀和可以快速求出连续元素的值，但我对它的时间复杂度了解程度不够好。

核心结论：滑动窗口如果是求值的话，右窗口滑动的同时，大概率会有某个参数要进行操作，后续进行比较从而操作左窗口，这是一个连续过程，所以题目得是连续问题。

2 简要回答

因为数组元素都是正数，可以使用滑动窗口。右指针不断扩展并累加区间和；当区间和大于等于 target 时，持续移动左指针缩短区间并更新最小长度。两个指针都只向右移动，时间复杂度是 $O(n)$。

3 详细回答

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int left = 0;//左指针
        int right = 0;//右指针
        int sz = nums.size();
        int res = sz+1;
        int sum = 0;
        while(right != sz){
            sum += nums[right];
            while(sum >= target){//注意,判断left移动是一个连续过程
                res = min(res , right-left+1);
                sum -= nums[left++];
            }
            right++;
        }
        if(res == sz+1){
            return 0;
        }else{
            return res;
        }
    }
};

4 前缀和思路是否可行

可以。 设前缀和为 prefix，因为题目中的元素都是正整数，所以 prefix 严格递增。对每个左端点，可以二分查找第一个满足区间和大于等于 target 的右端点。

只用前缀和枚举左右端点：$O(n^2)$
前缀和 + 二分查找：$O(n\log n)$
滑动窗口：$O(n)$

滑动窗口更快的关键也是"元素全为正数"：右端点右移时区间和只会增大，左端点右移时区间和只会减小，因此两个指针都不需要回退。

易错或补充：比如数组 [1,1,1,1,100]，target = 100，滑动窗口的 res 初始值（sz+1）要够大，否则取不到正确答案。

Q525 连续数组（前缀和 + 哈希）

Fri, 17 Jul 2026 00:00:00 +0000

来源：本题是 LeetCode 525，前缀和 + 哈希表的典型应用。这篇是我从 Obsidian 笔记整理过来的第一篇博客文章。

1 一、解题核心转化

1.1 1. 数值映射（关键技巧）

0 → -1，1 → 1

子数组 0、1 数目相等 ⇨ 子数组所有元素相加 = 0
问题转化：找最长区间和 = 0 的连续子数组

1.2 2. 前缀和公式

$$preSum[r] - preSum[l] = 0 \iff preSum[r] = preSum[l]$$

若两个位置前缀和相等：区间 $[l, r-1]$ 和为 0，满足题意
区间长度：$r - l$

2 二、易错点：vector 初始化大坑（踩坑记录）

1
2
3
4


// ❌ 错误写法：{n+1,0} 是初始化列表，生成【两个元素：n+1、0】
vector<int> preSum{n+1,0};
// ✅ 正确写法：(容量,初始值)，开辟 n+1 个空间全部赋值 0
vector<int> preSum(n+1,0);

报错原因：vector 实际只有 2 个元素，循环访问 preSum[i+1] 下标越界 → heap-buffer-overflow 堆溢出

3 三、算法步骤

构造前缀和数组：$preSum[0]=0，preSum[i]=preSum[i-1]+(nums[i-1]==0?-1:1)$
哈希表 unordered_map<前缀和, 首次下标>，预先存入：map[0]=0（处理从数组开头就满足条件的子数组）
遍历前缀和：
- 前缀和未出现：存入哈希（只存第一次下标，保证最长区间）
- 前缀和已存在：计算区间长度 i - map[preSum[i]]，更新最大值

4 四、C++ 完整 AC 代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include 
#include 
#include 
using namespace std;

class Solution {
public:
    int findMaxLength(vector<int>& nums) {
        int n = nums.size();
        vector<int> preSum(n + 1, 0); // 重点：圆括号初始化
        // 构建前缀和
        for(int i = 0; i < n; ++i){
            preSum[i+1] = preSum[i] + (nums[i]==0 ? -1 : 1);
        }
        unordered_map<int, int> mp;
        mp[0] = 0; // 初始化边界
        int res = 0;
        for(int i = 1; i <= n; ++i){
            auto it = mp.find(preSum[i]);
            if(it == mp.end()){
                mp[preSum[i]] = i; // 首次出现才保存
            }else{
                res = max(res, i - it->second);
            }
        }
        return res;
    }
};

5 五、复杂度分析

时间：$O(n)$，两次线性遍历
空间：$O(n)$，前缀和数组 + 哈希表

6 六、同类题型总结（前缀和 + 哈希通用模板）

LeetCode560 和为 K 的子数组：pre[r] - pre[l] = K
LeetCode974 和可被 K 整除子数组：同余前缀和配对

通用套路：前缀和做差转化区间条件 + 哈希存首次下标

7 七、精简优化版（不开前缀和数组，原地累加 sum 省空间）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


int findMaxLength(vector<int>& nums) {
    unordered_map<int,int> mp;
    mp[0]=-1;
    int sum=0,maxlen=0;
    for(int i=0;i<nums.size();i++){
        sum += nums[i]==1?1:-1;
        if(mp.count(sum)) maxlen=max(maxlen,i-mp[sum]);
        else mp[sum]=i;
    }
    return maxlen;
}

Q560 和为 K 的子数组

Fri, 17 Jul 2026 00:00:00 +0000

题目：给你一个整数数组 nums 和一个整数 k，请你统计并返回该数组中和为 k 的连续子数组的个数。

1 解题核心思路

1.1 1. 为什么用前缀和？

题目要求相邻子数组的和等于 K，前缀和天然适合处理区间和：

$$preSum[r] - preSum[l] = K \iff preSum[l] = preSum[r] - K$$

1.2 2. 为什么用哈希表？

要从大量子数组中快速找出满足条件的数量。暴力双 for 循环复杂度 $O(n^2)$，哈希表可以降到 $O(n)$。

哈希表的核心作用：空间换时间——当题目既要计算子数组情况，又要从子数组中快速查找满足条件的项时，哈希表是首选工具。

1.3 3. 哈希表存什么？

场景	哈希表记录
求数量（本题）	`val → count`（前缀和 → 出现次数）
求最大/最小长度	`val → index`（前缀和 → 首次下标）

2 算法步骤

遍历数组，维护当前前缀和 sum
计算 need = sum - K，在哈希表中查找 need 出现的次数，累加到结果
将当前 sum 存入哈希表（次数 +1）
关键初始化：map[0] = 1，处理从数组开头就满足条件的子数组

3 C++ 完整 AC 代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include 
#include 
using namespace std;

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        unordered_map<int, int> valToCount; // 前缀和 → 出现次数
        valToCount[0] = 1;                  // 边界初始化
        int sum = 0, res = 0;

        for (int num : nums) {
            sum += num;                     // 累加当前前缀和
            int need = sum - k;
            if (valToCount.find(need) != valToCount.end()) // 此处为满足需求
            {
                res += valToCount[need];
            }
            valToCount[sum]++;
        }
        return res;
    }
};

4 复杂度分析

时间复杂度：$O(n)$，一次遍历
空间复杂度：$O(n)$，哈希表最坏存 n 个不同前缀和

5 精简优化版（不开前缀和数组，一次遍历）

原代码先构造完整 preSum 数组再遍历，多了一次 $O(n)$ 的预处理。改为一边累加一边查哈希表，只扫一遍。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


int subarraySum(vector<int>& nums, int k) {
    unordered_map<int, int> mp;
    mp[0] = 1;
    int sum = 0, ans = 0;
    for (int x : nums) {
        sum += x;
        if (mp.count(sum - k)) ans += mp[sum - k];
        mp[sum]++;
    }
    return ans;
}

6 同类题型总结（前缀和 + 哈希通用套路）

题目	转化条件	哈希表记录
LeetCode 560 和为 K 的子数组	`pre[r] - pre[l] = K`	前缀和 → 出现次数
LeetCode 525 连续数组	`pre[r] = pre[l]`（0→-1, 1→1）	前缀和 → 首次下标
LeetCode 974 和可被 K 整除	同余前缀和配对	余数 → 出现次数

通用套路：前缀和做差转化区间条件 → 哈希表快速查找 → 根据题目要求决定存次数还是存下标。

7 易错提醒

valToCount[0] = 1 不能漏：当 sum == k 时，need = 0，此时应计为一种合法方案。
先查哈希表再更新：避免 k = 0 时当前前缀和自己匹配（空子数组不算）。