老李校长很多刚开始刷算法题的朋友都有过这种经历：题目一看就懂，思路秒出，代码写起来也就十几行，结果一提交，超时。尤其是那种“给一个数组，然后来 m 次询问，每次问某个区间里的和”的题，最朴素的做法就是每次询问都从 l 到 r 循环累加一遍。数据量小的时候没什么感觉，一旦数组长度到 10^5、询问次数也到 10^5，最坏情况就是 10^10 次加法，电脑当场罢工。这时候你就需要把眼光放到两个基础但极其重要的工具上：前缀和（Prefix Sum）和差分（Difference Array）。
这两个东西是算法竞赛里的地基，也是算法工程师面试时喜欢考察的基础数据结构。它们的思想不复杂，却能让你把一个循环累加的问题复杂度从 O(n) 直接压到 O(1)。更妙的是，前缀和和差分是一对互逆操作，一个解决“区间查询”问题，一个解决“区间修改”问题，组合起来能在很多看似复杂的题目里派上大用场。
这篇文章我不打算堆一堆理论公式就完事，而是从实际做题的角度，把两个东西的原理、代码模板、边界条件、常见坑和面试考察方式都过一遍。你可以把它当成一份可以直接抄作业的手册，也可以当成一次完整的思路复盘。
1. 为什么暴力枚举在这个问题上行不通
1.1 一次最常见的求区间和场景
先看一个实际场景。假设你有一个长度为 n 的数组 a，下标从 1 到 n。接下来有 m 次操作，每次操作输入两个数字 l 和 r，要求输出 a[l] 到 a[r] 的累加和。如果 n 和 m 都小于等于 1000，你写个双重循环是没有问题的，因为总计算量最多 10^6，计算机轻松扛住。
但题目往往没这么仁慈。当 n 和 m 都来到 10^5 甚至 10^6 时，暴力的方式就完全失控了。因为最坏情况下，每次询问都要遍历近乎整个数组，复杂度是 O(m × n)，也就是 10^10 次加法。当今普通计算机每秒能执行大约 10^8 到 10^9 次简单运算，这种规模的计算量需要几十秒甚至更久，妥妥超时。
1.2 从暴力枚举到预处理的关键一步
暴力代码之所以慢，是因为它每次都在重复计算。比如你第一次问了区间 [3, 7] 的和，第二次又问 [4, 8] 的和，这两个区间有大量重叠部分 [4, 7]，但暴力做法把这段重叠的和又算了一遍。这显然是一种浪费。
一个很自然的想法是：能不能提前把一些常用的计算结果存下来，等查询的时候直接取？这就是前缀和的核心思想——提前预处理一个数组，让每次查询变成一次减法运算。
时间复杂度从 O(n) 降到 O(1)，不是靠什么高深算法，而是靠“空间换时间”和“预计算”。这种思路在算法里非常普遍，逻辑上也很朴素，但很多人第一次接触时反而会被“前缀和”这个术语吓住，觉得神秘。其实说白了，它就是“前面所有元素的和”。
1.3 哪些题目类型适合用前缀和
前缀和不只是用来求区间和的。凡是那种“多次查询一段连续区域内的某种累积值”的问题，都可以往这个方向想。常见的包括：
- 区间和查询：最基础的类型，直接套公式。
- 区间平均值、区间乘积（注意乘法的模运算处理）：本质思想相同。
- 统计区间内某个值出现的次数：把原数组转为 1/0 标记数组再做前缀和。
- 前缀和配合其他数据结构：比如“前缀和 + 哈希表”解决子数组和为 K 的个数问题，这是个非常高频的面试题。
所以，前缀和是一个“思路工具”，它不绑定某一个特定题目，而是一种通用的预处理策略。掌握了它，你在看到区间类问题时思路会开阔很多。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 一维前缀和：从定义到代码模板
2.1 定义和构建过程
定义很简单。假设原数组为 a，下标从 1 开始。我们构造一个新的数组 pre，其中 pre[i] 表示数组 a 从第 1 个元素到第 i 个元素的累加和，也就是：
- pre[0] = 0（这是一个非常重要的边界，后面会讲）
- pre[1] = a[1]
- pre[2] = a[1] + a[2]
- pre[i] = pre[i-1] + a[i]
构建过程只需要一次遍历，时间复杂度 O(n)，空间复杂度 O(n)。构建时有个细节：pre[0] 必须初始化为 0。这个 0 不是随便填的，它是为了统一公式而刻意设计出来的“哨兵”，能让你在求区间 [1, r] 的和时直接用 pre[r] - pre[0]，不用单独写 if 判断。
很多人会好奇为什么下标要求从 1 开始而不是从 0 开始，原因就在这个 pre[i-1] 上。如果你用 0 下标，当 i 为 0 时，i-1 就变成 -1，数组越界，处理起来很麻烦。从 1 开始，你就多了一个 pre[0] 作为缓冲，逻辑会顺很多。
2.2 区间和查询公式怎么来的
有了 pre 数组，任意区间 [l, r] 的和可以用下面这个公式计算：
sum(l, r) = pre[r] - pre[l-1]
这个公式怎么理解？pre[r] 是 a[1] 加到 a[r] 的总和，pre[l-1] 是 a[1] 加到 a[l-1] 的总和，两者相减，中间恰好剩下的就是 a[l] 到 a[r]。这就像你用一把总长度减去前面一段长度，剩下的就是中间那段长度，很直观。
举个例子，数组 a = [3, 1, 4, 1, 5, 9, 2, 6]，求区间 [3, 6] 的和。先构建 pre：
- pre[0] = 0
- pre[1] = 3
- pre[2] = 4
- pre[3] = 8
- pre[4] = 9
- pre[5] = 14
- pre[6] = 23
- pre[7] = 25
- pre[8] = 31
然后直接算 pre[6] - pre[2] = 23 - 4 = 19。手动检查：a[3] + a[4] + a[5] + a[6] = 4 + 1 + 5 + 9 = 19，完全一致。一次询问只做两次数组访问和一次减法，稳得很。
2.3 模板代码
用 C++ 写大概是这样的：
cpp复制#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
long long a[N], pre[N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pre[i] = pre[i - 1] + a[i]; // 边读入边构建前缀和
}
while (m--) {
int l, r;
cin >> l >> r;
cout << pre[r] - pre[l - 1] << "\n";
}
return 0;
}
Python 版本：
python复制n, m = map(int, input().split())
a = [0] + list(map(int, input().split())) # 下标从1开始
pre = [0] * (n + 1)
for i in range(1, n + 1):
pre[i] = pre[i - 1] + a[i]
for _ in range(m):
l, r = map(int, input().split())
print(pre[r] - pre[l - 1])
这里的 long long（或 Python 的 int 不担心溢出）是必须的。如果数组元素是 int 范围，累加和很容易超出 32 位整数的上限。C++ 里用 int 存前缀和，在很多题目里会直接 WA（Wrong Answer），而且这种错误很难排查，因为不是逻辑问题，是精度问题。
2.4 一个值得注意的小优化
有些情况下 n 很大，但查询次数 m 很小，这时候是否还要构建完整的前缀和？我见过有些人不管三七二十一，先构造完再说，其实没必要。如果 m 远小于 n，你可以直接用离线处理（把查询排序后一次性扫描），或者干脆暴力。但常规题里 m 和 n 同阶，前缀和都是最优解。做题时还是要看一眼数据范围，别盲目套模板。
3. 差分：让区间批量修改变成 O(1) 操作
3.1 差分数组的直观理解
如果说前缀和是从前向后累加，那差分可以理解成它的逆操作：记录相邻两个元素之间的差值。
给定数组 a，构造差分数组 b，其中：
- b[1] = a[1]
- b[2] = a[2] - a[1]
- b[i] = a[i] - a[i-1]
- 也可以定义 b[i] = a[i] - a[i-1]，然后 a[i] = b[1] + b[2] + ... + b[i]
换句话说，对差分数组 b 求前缀和，就能还原出原数组 a。这个“还原”关系是理解差分的钥匙。
差分这个工具的核心使用场景是对原数组的某个连续区间 [l, r] 做“整体加一个数”或“整体减一个数”的修改。如果用朴素方法，区间内每个元素都要更新，一次修改就是 O(n)。但用差分数组，一次修改只需要改两个位置：
b[l] += v
b[r + 1] -= v
然后当你在最后需要把原数组的值求出来时，对 b 做一次前缀和还原即可。
为什么改两个位置就够了？因为 b 记录的是“变化”。b[l] += v 相当于告诉系统：从位置 l 开始，增量提升了 v；而 b[r+1] -= v 相当于告诉系统：从 r+1 开始，这个增量要撤销掉。中间那段 [l, r] 在还原时自然就带着 v 的增量。
3.2 从一次区间修改来看差分的执行过程
还是用一个例子。假设 a = [1, 2, 3, 4, 5]，我们要把区间 [2, 4] 里的每个元素都加上 10。
先构建差分数组 b：
- b[1] = 1
- b[2] = 2 - 1 = 1
- b[3] = 3 - 2 = 1
- b[4] = 4 - 3 = 1
- b[5] = 5 - 4 = 1
差分数组通常还要开一个哨兵位置 b[n+1]，用来接收 r+1 处的减法，防止数组越界。
执行修改：
- b[2] += 10 → b[2] = 11
- b[5] -= 10 → b[5] = -9（注意这里 r+1 = 5，正好是 n+1 的位置，如果数组长度只有 5，需要申请到 n+2）
然后对 b 求前缀和还原：
- a[1] = b[1] = 1
- a[2] = b[1] + b[2] = 1 + 11 = 12
- a[3] = b[1] + b[2] + b[3] = 13
- a[4] = b[1] + b[2] + b[3] + b[4] = 14
- a[5] = 1 + 11 + 1 + 1 + (-9) = 5
结果就是 a = [1, 12, 13, 14, 5]，和预期的 [1, 12, 13, 14, 5] 一致。
一次性多次修改就更有优势了。假设你接下来还要把 [1, 3] 加 5、把 [3, 5] 减 2，每次操作仍然只需要改两个点，最后统一做一次前缀和，把所有修改一次性叠加到最终数组上。
3.3 差分的读入时初始化技巧
很多时候题目输入直接给的就是“先给你初始数组，再做若干次区间修改”。这种场景下，初始数组转差分的操作可以“在写入时顺便完成”，不用先存原数组再算差分。
具体做法是：假设原数组初始值全部为 0，读入第 i 个位置的值 v 时，等价于做一次“单点赋值”操作，也就是把区间 [i, i] 加上 v。用差分的语言来写就是：
cpp复制b[i] += v;
b[i + 1] -= v;
这样读入结束，差分数组就已经构建好了，省掉了一次额外的遍历。我第一次写差分时直接存了原数组再求差值，代码啰嗦一圈；后来发现这种写法既简洁又不容易出错，尤其适合从 1 开始计数的场景。
3.4 差分的边界条件
差分里最经典的边界坑就是数组长度。因为区间 [l, r] 的修改要操作 b[r+1]，所以数组长度需要开 n+2，而不是 n。很多人在小数据测试时没问题，一上大数组就报越界或者出现奇怪结果，十有八九是这里出了问题。
另外，如果原数组下标从 1 开始，差分数组也要从 1 开始，保持一致性。差分和前缀和是同一套下标体系，混用两套下标会让代码可读性下降，也容易产生 off-by-one 错误。
4. 二维扩展：矩阵上的前缀和与差分
4.1 为什么需要二维版本
处理一维数组的区间问题只是入门，二维矩阵上的问题才是真正展现前缀和和差分价值的地方。比如给定一个 n × m 的矩阵，进行 q 次询问，每次询问一个子矩阵的所有元素之和。如果暴力求解，每次查询都要遍历子矩阵，最坏情况 O(n × m × q)，直接爆炸。
二维前缀和能把每个子矩阵求和降到 O(1)，代价是预处理 O(n × m) 的时间和空间。这在图像处理、二维网格统计类问题里极其常用。
4.2 二维前缀和的递推公式
定义二维前缀和数组 S[i][j]，表示从矩阵左上角 (1, 1) 到 (i, j) 这个矩形区域内所有元素的和。递推公式为：
S[i][j] = S[i-1][j] + S[i][j-1] - S[i-1][j-1] + a[i][j]
这个公式看着有点绕，其实用容斥原理理解就很简单：S[i-1][j] 覆盖了上面部分，S[i][j-1] 覆盖了左边部分，两者相加把左上角那块 S[i-1][j-1] 加了两次，所以要减回去一次，最后再加上当前格子的值 a[i][j]。
求任意子矩阵 (x1, y1) 到 (x2, y2) 的和时，同样用容斥：
sum = S[x2][y2] - S[x1-1][y2] - S[x2][y1-1] + S[x1-1][y1-1]
还是那个逻辑：拿总矩形减去上方和左方两个矩形，左上角重叠部分被减了两次，要加回来。
4.3 二维差分的区间修改
二维差分和二维修改对应。给定一个矩阵，要多次将某个子矩阵区域整体加上 v。做法是构造二维差分数组 D，使得对 D 求二维前缀和可以还原出原矩阵。
每次对子矩阵 (x1, y1) 到 (x2, y2) 加 v，只需要在四个位置操作：
cpp复制D[x1][y1] += v;
D[x1][y2 + 1] -= v;
D[x2 + 1][y1] -= v;
D[x2 + 1][y2 + 1] += v;
第一次看到这个四位置修改可能一头雾水，但用容斥原理同样能解释：你要在差分矩阵中制造一个“信号”，让这个信号在二维前缀和还原时恰好只影响目标子矩阵。四个点的加加减减，和二维前缀和递推公式里的加减号是一一对应的。
二维差分构建时也可以利用初始化技巧：读入矩阵元素时，直接在差分数组上做单点修改（相当于对该点加 v），最后统一做二维前缀和还原。
4.4 空间与实现的取舍
二维前缀和会直接多开一个 n × m 的 long long 数组。如果 n 和 m 都到 10^3，那内存大概是 8 MB，没问题；如果到 10^4，那就是 800 MB，内存直接爆掉。所以做题前一定先算一下内存。遇到高维但稀疏的场景，可以考虑哈希表存差分点，或者用离线算法压缩维度。
在实际工程里，如果矩阵很大，我更倾向于把二维前缀和改写成滚动数组，或者只保留差分数组、最后一次性还原。这样内存占用能减到 O(min(n, m))，但代码会复杂不少。面试中很少要求做到这一步，但能说出来会是加分项。
5. 前缀和和差分怎么配合使用
5.1 两个数组的合并使用场景
有些题既要求区间修改，又要求区间查询，这时候单独用前缀和或差分都不够，需要组合起来用。一个典型场景是：先给原数组做若干次区间加值操作（用差分），全部操作结束后，再频繁查询区间和（用前缀和）。
操作步骤是：
- 用差分数组高效完成所有区间修改。
- 对差分数组求一次前缀和，得到最终数组。
- 对最终数组再求一次前缀和，得到可 O(1) 查询区间和的 pre 数组。
两个工具像流水线一样衔接起来。这个套路在“一次修改 + 多次查询”类型的题目里非常通用。
5.2 前缀和配合哈希表解决子数组问题
面试里最经典的前缀和变形题大概是“给定一个数组，求连续子数组的和等于 k 的个数”。暴力枚举需要 O(n^2)，但用前缀和配合哈希表可以做到 O(n)。
思路是：遍历数组时，维护当前位置之前所有前缀和的出现次数。对于每个位置 i，看看有没有前缀和 pre[j] 满足 pre[i] - k，如果有，说明存在 [j+1, i] 这段区间和为 k。用哈希表存每个前缀和出现的次数，查询一次 O(1)。
这里的核心思维是“前缀和 + 哈希表”的配对，本质是把“区间和”转换成“两个前缀和的差”，再用哈希表加速查找。这类题目考察的其实不是前缀和本身，而是你能不能想到用“前缀和之差”这个等价关系。
5.3 和树状数组、线段树等数据结构的边界区分
前缀和和差分能解决的场景非常有限，但它们足够轻量。经常有读者问：什么时候用前缀和，什么时候用树状数组，什么时候上线段树？
我一般这样区分：
- 如果只需要静态查询（数组不变），前缀和是首选，复杂度最优且实现最简单。
- 如果需要“单点修改 + 区间查询”，前缀和派不上多大用场（修改 O(n)），但树状数组能在 O(log n) 内完成单点修改和区间查询。
- 如果需要“区间修改 + 区间查询”，差分只能处理修改后的最终结果，而树状数组加技巧或线段树可以动态处理。
- 如果修改和查询都很复杂（区间修改的同时查询区间最值），直接用线段树。
前缀和和差分就像是一把趁手的小刀，树状数组和线段树则是瑞士军刀。小刀能解决的场景用军刀反而笨重，但军刀能解决的问题小刀也替代不了。工具选型本身就是算法能力的体现。
5.4 离散化：当坐标很大时怎么办
有些题目里数组下标不是 1 到 n，而是 1 到 10^9。这时候直接开一个 10^9 的数组肯定内存爆炸。处理方式是把所有用到的下标收集起来，排序去重，然后映射成 1 到 m 的小坐标。这就是离散化。
前缀和和差分都能配合离散化使用。比如你只需要在 1、100、10000 这三个点做修改，那就只需要一个长度为 4 左右的差分数组。离散化后要注意：原下标之间的空隙可能在区间修改时也受影响，如果修改覆盖了两个离散下标之间的区间，需要把整段映射成虚拟点，或者用加权的方式记录长度。这是离散化 + 差分的一个隐蔽难点，刷题时碰到过几次，每次都值得多花几分钟想清楚。
6. 实战中容易踩的坑和面试官想考的点
6.1 下标从 1 开始还是从 0 开始？
这是我见过最多的争论，也是 off-by-one 错误的重灾区。我的建议是：在竞赛和面试手写代码时，一律用从 1 开始的下标体系。原因很简单，前缀和和差分的模板都依赖哨兵位置（pre[0] 和 b[n+1]），从 1 开始写可以少写很多边界判断。
从 0 开始也能写，但你每次查询 sum(l, r) 要格外小心：如果是左闭右开区间 [l, r)，那公式是 pre[r] - pre[l]；如果是闭区间 [l, r]，那公式是 pre[r+1] - pre[l]。两种写法都能对，但在紧张状态下很容易混。
6.2 溢出问题
C++ 里前缀和数组不定义成 long long，几乎等于给自己埋雷。int 最大值约 2.1 × 10^9，一个 10^5 级别的数组，只要每个元素是 10^4 级别，累加和就轻松过亿。连续溢出之后计算出的区间和完全错乱，而且很难从结果特征上判断是算法问题还是精度问题。
我这里有个小习惯：只要涉及累加和、累乘、区间统计，先默认 long long，只有在题意明确保证结果不超 int 范围时才用 int。这种“宁可全 long long”的写法牺牲不了多少性能，但能省很多调试时间。
6.3 差分数组的大小和边界位置
差分数组开 n+2，这多出来的两个位置是干什么的？一个是下标 n+1，为了存 r = n 时那个 b[r+1] -= v；另一个是下标 0，虽然一般不用，但保持一致也无妨。
写提交代码时我习惯直接定义 vector<long long> diff(n + 5, 0)，留点余量，避免越界。这不是什么高级技巧，但能省去很多因为边界访问导致的 Runtime Error。
6.4 多次操作后别忘了还原
差分的执行模式和前缀和不同。你做了一堆区间修改之后，如果直接输出原数组，很多新手会困惑“为什么数组没变化”。因为差分数组本身不是最终答案，必须做一次前缀和还原才得到修改后的数组。这个步骤容易漏掉，尤其在代码冗长时。
一个可复用的检查顺序是：修改完了，先求一次前缀和，验证某个位置的值是否符合预期，再继续往下的逻辑。
6.5 面试官视角：从暴力到优化的完整叙事
算法工程师面试里，面试官很少直接扔一个“请写前缀和”的题，而是给一个看似复杂的场景，比如“设计一个数据结构，支持往数组里追加元素、查询任意区间和”。这种题的核心就是让你自己发现前缀和的变体。
应对面试的关键不只是写出代码，而是要能把思路过程讲清楚：先描述暴力怎么做，指出瓶颈在哪里，然后解释为什么预处理能解决问题，代价是什么（额外空间）。面试官想听到的是这种“权衡”的表达，而不是直接背公式。
我自己在面试别人时，经常出一个“二维矩阵多次子矩阵求和”的题，看看候选人能不能现场推出二维前缀和的容斥公式，这比背出模板更能反映对原理的理解程度。推公式的过程本身就是能力的体现。
7. 一些个人的实战心得
说了这么多，最后分享一个我做题时的习惯：拿到一道数组区间类的题，先花 30 秒判断一下操作类型，到底是以查询为主还是以修改为主。如果修改少查询多，直接前缀和；如果修改多查询少，用差分；如果修改和查询都很频繁，则考虑更高级的数据结构。这个判断 30 秒就能完成，但能帮你省下大量的试错时间。
另外，刷题时不要满足于 AC（Accepted），可以把每个前缀和/差分题再想一步：如果元素被修改了怎么办？如果数组变成二维了怎么处理？如果坐标离散化了怎么应对？每多想一步，你对这两个工具的理解就会深一层。
前缀和和差分看似简单，但它们是通往更高阶数据结构的一座重要桥梁。树状数组的底层原理、线段树的懒标记、甚至离线算法中的莫队思想，都和“前缀和思维”有着千丝万缕的联系。把这个地基打扎实，再去学那些复杂的东西，你会发现一切都顺理成章得多。