前缀和与差分：从区间求和到二维矩阵快速更新的核心算法

刷题久了你会发现，很多看起来不难的问题最后都卡在“反复问某个范围内的总和”上。而只要提到这类题，就绕不开前缀和、差分、差分矩阵这套非常经典的技巧；进一步说，一旦情景从一维数组变成二维矩阵，比如算一个子矩阵里所有数字的和，又变成了二维前缀和的舞台。如果有人问我在算法竞赛、面试笔试里最优先要掌握的“性价比”算法是什么，我大概率会推荐这一组：前缀和、子矩阵和、差分、差分矩阵。

它们没有什么高深数学门槛，几行递推就能写出来，却能把很多看起来会超时的暴力循环直接优化一个量级。我刚开始打比赛的时候，习惯一股脑地对每个区间重新累加，结果提交后超时卡到怀疑人生。后来认真把“前缀和”和“差分”这套互为逆向的工具放到一起整理，才发现它们的组合能解决一大批区间静态查询、区间批量更新问题。这篇文章不为讲花哨的高阶技巧，就踏踏实实把这四个概念拆开，配合思路分析和调试记忆，让刚接触的人也能把它们写成自己的模板。

1. 从一个老问题聊起：区间求和的暴力做法到底慢在哪

先看一个特别常见的题目描述：给定一个长度为 n 的数组，多次询问某个区间 [l, r] 内所有元素的和，n 和询问次数都可能到达 1e5 甚至 1e6。最容易想到的办法是每次询问都用一个循环从 l 累加到 r。这个循环看起来很简单，但实际运算量大约是询问次数乘区间平均长度。如果 n 和 q 都是 1e5，最坏情况下要做 1e10 次加法，在竞赛环境中基本会超时。

这里涉及到一个时间复杂度估算的问题。很多人一开始没有估算意识，觉得“每次累加，最多几万次，应该没问题”，可一旦数据规模到了 1e5 以上，朴素版本的代价就藏不住了。现场被打回提交后，最朴素的优化思路就是：能不能提前把“从起点到当前位置的和”记下来？同样的场景放到生活里，相当于你有一本账本，如果每次想知道某几天一共花了多少钱，你都从头加一遍，那会很慢。更好的做法是一开始就维护一个“累计金额”列表，第 i 天存的是从第 1 天到第 i 天的累计花费。

所以，程序里的前缀和数组 pre[i] 就用来记录原数组 a[1] 到 a[i] 的累加和。有了这张表，任意区间 [l, r] 的和就不再需要循环累加，直接通过 pre[r] - pre[l-1] 一步算出来。这样构造前缀和数组的时间是 O(n)，之后每次查询是 O(1)，整体从 O(nq) 降成 O(n+q)，效果会非常明显。在我看来，前缀和最核心的思想就是把“重复计算”变成“预先计算”，这是所有区间类问题里非常值得记住的优化逻辑。

1.1 前缀和数组的定义与递推式

写代码之前先把定义说清楚。为了处理边界方便，我习惯让数组从下标 1 开始使用，并把 pre[0] 设置为 0。对于原数组 a[1..n]，定义：

pre[i] = pre[i - 1] + a[i]

如果要查询 a[l] 加到 a[r] 的和，直接用：

sum(l, r) = pre[r] - pre[l - 1]

为什么是 pre[l - 1] 而不是 pre[l]？因为 pre[r] 里面已经包含了 a[1] 到 a[r] 的总和，pre[l - 1] 是 a[1] 到 a[l - 1] 的总和。两者做差，a[1] 到 a[l-1] 这一整段被抵消，剩下的正好是 a[l] + ... + a[r]。边界处理上，如果 l = 1，那么 pre[0] = 0，pre[r] - pre[0] 也依然正确。这一招在很多竞赛模板里都能直接套用。

构造的过程写成代码也特别短：

cpp复制int n;
vector<long long> a(n + 1), pre(n + 1, 0);
for (int i = 1; i <= n; ++i) {
    pre[i] = pre[i - 1] + a[i];
}

查询的时候这样写：

cpp复制long long range_sum = pre[r] - pre[l - 1];

1.2 从一维到“能不能更通用一点”

有的读者可能觉得，这只是从“每次 O(n)”变成“预处理 O(n) + 查询 O(1)”，好像不算特别惊艳。但前缀和的真正威力在于它作为一种“预处理工具”，可以和其他技巧嵌套使用。比如配合二分，可以在排序后快速判断满足条件的区间；配合哈希表，可以统计和为某值的子数组数量；再往深走一点，还有二维前缀和、树上前缀和、差分前缀和等一堆延伸。

我在实际做题时总结过一个选择信号：如果题目给的数组是静态的，所有操作都是查询，没有任何中间修改，那一旦出现“多次问某个区间/某个区域的数字和”，第一反应就应该是前缀和。为什么强调静态？因为要是中间频繁修改数组元素并继续查询，普通前缀和每次都要重新构造，就不划算了，此时要换线段树或树状数组的思路。理解前缀和的适用边界，比单纯记住公式要重要得多。

2. 差分：区间统一增减的“反向操作”

把前缀和弄明白之后，差分学起来会快很多。从数学上看，差分数组和前缘和数组是一对“互逆关系”：如果 pre 是 a 的前缀和，那么 a 也可以认为是 pre 的差分。差分记录的不是“当前和”，而是“当前位置相对前一个位置的变化量”。

为什么要记录变化量？因为现实里我们会遇到另一类题目：给定一个数组，进行非常多次区间操作，每次把 [l, r] 内的所有数统一加 c，等所有操作全部结束之后，再输出最终的数组。如果每次操作都去 for 循环更新区间内的每个元素，一次区间操作就是 O(n)，多次操作之后复杂度爆炸。差分数组能把这个区间更新的过程压缩成两次单点操作，让每次操作的代价降为 O(1)。

2.1 差分数组的定义

假设有一个长度为 n 的数组 a，定义差分数组 diff[i] = a[i] - a[i - 1]，其中 a[0] = 0。反过来，也可以用差分数组恢复原数组：a[i] = a[i-1] + diff[i]。

这个定义看起来平平无奇，但把它和区间更新结合起来，就会有化学反应。如果希望 a 中区间 [l, r] 的所有元素都加 c，我们不需要真的去改 a，只需要修改 diff 的两个位置：

diff[l] += c
diff[r + 1] -= c

为了直观理解，我们不妨造一个小例子。假设数组 a 全是 0，对应 diff 也全是 0。现在要让下标 2 到 4 全部加 5。按照上面的操作，diff[2] 变成 5，diff[5] 变成 -5。然后我们用前缀和还原 a：

i=1: a[1] = 0
i=2: a[2] = a[1] + diff[2] = 5
i=3: a[3] = a[2] + diff[3] = 5
i=4: a[4] = a[3] + diff[4] = 5
i=5: a[5] = a[4] + diff[5] = 0
i=6: a[6] = a[5] + diff[6] = 0

看到效果了吗？因为 diff[2] 处的 +5 使得从 2 开始的所有前缀和都多了 5，而 diff[5] 处又减掉 5，相当于这个“增量”在区间右边界之后失效，所以最终只有 [2, 4] 被加了。

2.2 区间加操作的基本套路与边界

写差分区间操作时，最关键的是不要漏掉右边界的减操作。很多人第一次写容易只保留 diff[l] += c，忘记了 diff[r + 1] -= c，结果后半个数组也被改了；还有人搞错边界，该在 r + 1 处减却写成了 r。如果数组下标从 1 开始，r + 1 最大可能是 n + 1，所以差分数组一般要额外留出一个位置。我在定义 diff 时通常会开 size 为 n + 2 的数组，就是为了防止在 diff[n+1] 赋值时越界。

下面是一个典型模板，比如给定 m 次操作，最后输出数组：

cpp复制int n, m;
cin >> n >> m;
vector<long long> diff(n + 2, 0);
while (m--) {
    int l, r;
    long long c;
    cin >> l >> r >> c;
    diff[l] += c;
    diff[r + 1] -= c;
}
vector<long long> a(n + 1, 0);
long long cur = 0;
for (int i = 1; i <= n; ++i) {
    cur += diff[i];
    a[i] = cur;
}

这里diff在构造后存的是“所有增量叠加后的变化量”，而不是原始数组的值。最后的 cur 相当于做前缀和恢复。如果你想从初始数组出发进行区间更新，通常有两种做法：一是把初始值作为若干次单点修改处理，把第 i 个位置加上 a[i]，等价于 diff[i] += a[i]，diff[i+1] -= a[i]；二是先构造一个初始差分数组，再叠加后续区间操作。这两种写法本质一样，核心是记住“对某段区间做加法，等价于对差分数组做两个单点修改”。

2.3 差分和前缀和是互补关系，不是替代关系

我见过不少初学者，学完差分后遇到静态区间求和也想用差分，这就属于概念没理清。差分适合“大量区间更新，最后少数次查询”的场景；前缀和适合“数组基本不变，大量区间查询”的场景。两者经常配合使用，比如先用差分完成所有修改，最后再对恢复出的数组做一次前缀和，用于支持后续多个查询。这里特别值得强调，差分的维护过程实际上也是前缀和思想的体现，因为最终一步都要做“累积”来恢复原数组。能把这个互逆关系内化成直觉，后面的二维差分会很好理解。

3. 子矩阵的和：二维前缀和是如何一步一步推出来的

学会一维问题后，二维场景就顺理成章了。现在给你一个 n 行 m 列的矩阵，多次询问某个子矩阵内部所有数字的和，比如左上角 (x1, y1) 到右下角 (x2, y2) 围成的矩形区域。如果暴力遍历这个区域，一次询问最坏要遍历整个矩阵尺寸范围的格子，通常无法接受。用二维前缀和预处理，每次查询任意矩形区域都能做到 O(1)。

二维前缀和的状态定义是：s[i][j] 表示从左上角 (1, 1) 到当前点 (i, j) 这个矩形里所有数字的总和。只要这张表构造出来，任意子矩阵的和就能通过四个数字的加减拼出来。这个思维和“把重复求和变成预处理”完全一致，只是从一维累加变成了二维矩形累加。

3.1 二维前缀和的递推公式

根据定义，(i, j) 位置左上方的矩形，可以看成三部分组合：上面 (1,1) 到 (i-1, j) 的整块，左边 (1,1) 到 (i, j-1) 的整块，再加上当前点 a[i][j]。如果直接把两个区域相加，会发现 (1,1) 到 (i-1,j-1) 这个公共部分被加了两次，必须减掉一次。所以公式是：

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] 被算了两次，所以必须减去。这个解释比单纯背公式可靠得多。

3.2 子矩阵和的查询公式

当 s 表构造完成后，要查询左上角 (x1, y1)、右下角 (x2, y2) 的矩形和，可以先看 s[x2][y2] 这个大矩形，减去上面多出来的部分 s[x1-1][y2]，再减去左边多出来的部分 s[x2][y1-1]，但左上角那小块 s[x1-1][y1-1] 被减了两次，需要加回来一次。于是：

sum(x1, y1, x2, y2) = s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1]

这个公式是有名的容斥结果。如果 x1=1，那么 x1-1=0，整个 s[0][...] 都是 0，不会影响答案。在写代码时我习惯把所有下标都从 1 开始，矩阵往外面多加一圈 0，这样既统一，又不容易让数组越界。尤其是差分矩阵还需要访问 x2+1、y2+1，预留一圈“0 边界”几乎是必须的。

3.3 一个三行三列的手算例子

为了让自己确认公式没记错，我常常会在草稿纸上手算小样例。假设一个矩阵：

1 2 3
4 5 6
7 8 9

它的 s 表应该如下，我直接列出常用计算值。s[1][1] = 1；s[1][2] = 1+2=3；s[1][3] = 6；s[2][1] = 1+4=5；s[2][2] = 1+2+4+5=12；s[2][3] = 1+2+3+4+5+6=21；s[3][1] = 1+4+7=12；s[3][2] = 1+2+4+5+7+8=27；s[3][3] = 45。

如果要查 (2,2) 到 (3,3) 的和，直观结果是 5+6+8+9=28。公式代入 s[3][3] - s[1][3] - s[3][1] + s[1][1] = 45 - 6 - 12 + 1 = 28。这个例子跑通后，代码里再用几个随机小矩阵和暴力版本交叉验证，心里就很踏实。

3.4 二维前缀和的复杂度和代码骨架

二维前缀和构造时间复杂度是 O(n*m)，因为每个格子计算一次；查询单次是 O(1)。这种特性非常适合“静态矩阵 + 多次询问矩形和”的题目。标准代码：

cpp复制int n, m, q;
cin >> n >> m >> q;
vector<vector<long long>> a(n + 1, vector<long long>(m + 1, 0));
vector<vector<long long>> s(n + 1, vector<long long>(m + 1, 0));
for (int i = 1; i <= n; ++i) {
    for (int j = 1; j <= m; ++j) {
        cin >> a[i][j];
    }
}
for (int i = 1; i <= n; ++i) {
    for (int j = 1; j <= m; ++j) {
        s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i][j];
    }
}
while (q--) {
    int x1, y1, x2, y2;
    cin >> x1 >> y1 >> x2 >> y2;
    long long ans = s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1];
    cout << ans << '\n';
}

这里要特别提醒，矩阵数据有时可能很大，而且多个大数累加后可能超过 int 范围。建议在题目空间允许时直接用 long long，别贪省那一点内存。遇到需要累加 1e5 个 1e9 级别素数的场景，int 溢出错得很隐蔽，排查起来相当费劲。

4. 差分矩阵：矩形区域快速修改的核心武器

二维差分其实是“一维差分的升级版”，解决的是这类问题：给定一个二维矩阵，执行很多次区域操作，每次让某个矩形区域内所有格子同时加同一个数值，等所有操作完成后，输出最终矩阵。如果每次操作都逐个格子遍历，操作次数和矩阵面积相乘，通常爆复杂度；差分矩阵能将矩形修改简化为四个角落的单点修改，最后做一次二维前缀和恢复。

我第一次看二维差分操作时觉得很突兀，完全没法理解“为什么改四个点就能改变一个矩形”。后来我换了一个角度去理解：如果每次矩形修改等价于在二维差分表上打四个标记，最后做一遍二维前缀和的时候，这些标记会像水面上的波纹一样叠加扩散，最终在目标矩形内部形成合法增量。这个角度比死记公式有效得多。

4.1 差分矩阵的构建思路

对于一个原始二维数组 a，我们可以先准备一个同尺寸的差分矩阵 d。构造 d 的理想方式是找一维差分在二维上的类比：一维中 diff[i] = a[i] - a[i-1]；二维中，要使 d 做二维前缀和以后能还原出 a，需要用容斥公式来倒推：

d[i][j] = a[i][j] - a[i - 1][j] - a[i][j - 1] + a[i - 1][j - 1]

这个式子和二维前缀和递推式在形式上很像，但方向相反。在实际题目里，如果初始全为 0，我们不需要关心 d 怎么构造；如果有初始矩阵，一个很实用的小技巧是把它看成若干次“单点矩形加操作”，把每个 a[i][j] 当作一次单位矩形加，套用下方的四角加标记即可。

4.2 矩形区域加法的四角标记

现在看核心操作：希望给左上角 (x1, y1) 到右下角 (x2, y2) 的整个矩形区域里的每个格子都加 value v。对差分矩阵 d，只需要执行：

d[x1][y1] += v
d[x2 + 1][y1] -= v
d[x1][y2 + 1] -= v
d[x2 + 1][y2 + 1] += v

之后再做一次二维前缀和，目标矩形内部就会全部加上 v。道理可以用一维差分延伸来理解：d[x1][y1] 的加号让以 (x1,y1) 为左上角的整个右下方向区域都增加了 v；d[x2+1][y1] 的减号截断了从第 x2+1 行开始的向下延伸；d[x1][y2+1] 的减号截断了从第 y2+1 列开始的向右延伸；但这两个减号会在 (x2+1,y2+1) 构成的右下角区域重复截断两次，所以必须再加回一个 v。

有读者可能觉得这个解释有点抽象。我自己理解的土办法是把二维矩形加想象为四根标记往下推，它们的相交区正好组成那个矩形。如果不放心，建议拿一个 4x4 的全零矩阵手推一遍。假设要更新 (2,2) 到 (3,3) 矩形，加 7，按公式打标后做二维前缀和，观察结果：

• 在矩阵第2行第2列到第3行第3列范围是7；
• 在第2行第4列以及第4行第2列开始之外都是0；
• 第4行第4列也回到0。

亲手推一次，比看十遍文章都有用。

4.3 初始化矩阵也走四角更新路线

当我们面对“初始矩阵不是全零”的题目时，有一个非常好用的思路：不要先开个二维数组 a 再慢慢转换，而是直接从零差分表开始，把每个原始值 a[i][j] 当作一次单点区域更新来处理。每次对格子 (i,j) 单独加 a[i][j]，这样会做四次修改：

d[i][j] += a[i][j]
d[i + 1][j] -= a[i][j]
d[i][j + 1] -= a[i][j]
d[i + 1][j + 1] += a[i][j]

不要担心操作次数，因为初始矩阵有 n*m 个元素，每个都是一次 O(1) 的差分修改，和朴素读入矩阵同数量级，不会带来额外负担。之后继续执行题目要求的矩形更新即可。等所有更新都结束，再对差分矩阵做一遍二维前缀和，得到的就是最终矩阵。

下面给一个带初始矩阵和矩形操作的标准代码模板，可以作为竞赛中的备用底稿。

cpp复制#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, m;
    cin >> n >> m;
    vector<vector<long long>> d(n + 2, vector<long long>(m + 2, 0));

    // 读入初始矩阵，并把每个点当作一次单点矩形加
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            long long x;
            cin >> x;
            d[i][j] += x;
            d[i + 1][j] -= x;
            d[i][j + 1] -= x;
            d[i + 1][j + 1] += x;
        }
    }

    int q;
    cin >> q;
    while (q--) {
        int x1, y1, x2, y2;
        long long v;
        cin >> x1 >> y1 >> x2 >> y2 >> v;
        d[x1][y1] += v;
        d[x2 + 1][y1] -= v;
        d[x1][y2 + 1] -= v;
        d[x2 + 1][y2 + 1] += v;
    }

    // 二维前缀和还原最终矩阵
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            d[i][j] += d[i - 1][j] + d[i][j - 1] - d[i - 1][j - 1];
            cout << d[i][j] << " \n"[j == m];
        }
    }
    return 0;
}

这里有个细节，就是每次对差分矩阵做二维前缀和是原地覆盖进行的。如果后续还需要继续执行矩形加操作，那千万不能提前做前缀和，否则差分数组的“差分语义”会被破坏。正确顺序永远是：先把所有矩形更新都打到 d 上，最后统一做一次前缀和恢复。

4.4 一块矩形叠加多次的模拟题

举个例子说明二维差分到底能解决什么问题。假设在一个空旷的公园里，我们把地面看成一个 n*m 的网格，初始全部是0。接着会有 k 批工人，每批负责给某个矩形区域的格子浇水一次。所有 k 批结束之后，我们想知道每个格子最终被浇了多少次。如果一次一次去遍历矩形里的格子，时间复杂度是 k * 平均面积；换成差分矩阵，每批操作只需要改四个点，最后做一次二维前缀和，一次更新变成 O(1)，非常舒服。

这类题在竞赛题里很常见，有时候换皮成“一个区域被多少海报覆盖”“平面上有几块广告牌叠在了一起”，本质上都是多次矩形区域加一。正因为二维差分降复杂度的效果太明显，所以一旦题目允许所有操作先离线做完、最终再输出结果，我就倾向于用它。

5. 常见错误与调试技巧实录

写前缀和、差分这类模板题，最大的麻烦不是公式本身，而是下标算错、边界漏掉、数据类型爆了。这些问题平时不手滑还好，一旦手滑就会让人陷入漫长的 debug。下面把我在实际做题中反复踩过、也见别人踩过的坑整理成一张速查表。

除开这些常见错误，我还想分享一个非常有用的调试方法：写一个朴素暴力版本，专门用来验证你的前缀和/差分版本。暴力逻辑很简单，别嫌它慢，小数据下根本不会超时。比如二维差分，先随机生成一个小矩阵，随机做若干次矩形加，然后分别用暴力遍历和差分矩阵方法得到两组结果。如果输出一致，基本可以确认模板没写错；如果不一样，就把小矩阵打印出来，逐格对比，很快就会发现问题。

另一个我常用的技巧是在关键循环里加临时输出，比如把差分矩阵打印出来。很多人纠结点位时靠猜，其实把 diff 矩阵打出来后，马上能看出标点是不是落在了预期位置，尤其能发现 d[x2+1][y1] 和 d[x1][y2+1] 这两处符号是否混了。等结果全部正确后再把调试输出删掉。

6. 从零复现一个综合小例题：棋盘染色

光看一堆公式不够，我建议把自己放进一次完整编程流程中。这里我们做一个非常综合的练习：有一个 n*m 的棋盘，初始所有格子都是 0。给出若干次操作，每次把 (x1, y1) 到 (x2, y2) 这个矩形区域内的所有格子加 c。操作结束后，再调用若干次查询，每次问某个子矩形区域内所有格子的总和。这道题能同时用到差分矩阵和二维前缀和。

第一步，先接收所有更新操作，全部打在差分矩阵 d 上，一步都不去提前算原矩阵。第二步，等所有更新结束，对 d 做一次二雏前缀和，得到最终每个格子的值 a。第三步，对刚得到的最终格子覆盖值再做一次二维前缀和，得到 s 表，用于子矩阵求和。这个流程看起来是“差分+前缀和”的两次叠加，但非常自然：差分负责高效修改，前缀和负责高效查询。

这里可以套用上一节的二维差分代码，不断在 diff 数组上执行矩形加；全部更新结束后再执行下面这段矩阵还原：

cpp复制for (int i = 1; i <= n; ++i) {
    for (int j = 1; j <= m; ++j) {
        d[i][j] += d[i - 1][j] + d[i][j - 1] - d[i - 1][j - 1];
    }
}

因为代码在同一个数组上原地做，需要按 i、j 递增的顺序遍历。有人可能会问，为什么不能按从大到小的顺序？因为 d[i][j] 的新值依赖左上三个位置的更新结果，按从左上到右下的自然顺序计算，才能保证依赖值已经算好。如果顺序乱了，叠加结果就会完全错乱。

获得最终 a 之后，如果想继续多次查询区间和，可以再把 a 的二维前缀和存到另一个 s 表。注意最好复制出新数组，不要继续复用 d，因为 d 虽然已经变成了 a 的值，但你后面还要在这个“当前值”上做前缀和，如果新开一个 s，逻辑会比较清晰，避免混乱。等到题目做完，你会发现代码步骤虽然多，但每一步都是熟悉的模板拼接。

7. 刷题与技术选型：什么时候该用哪个

在这几个技巧之外，我还想专门聊一下“何时选谁”，因为这个问题直接影响代码的编写思路。以前我写过不少用普通循环硬莽导致超时的题，后来才慢慢形成一套判断顺序。

第一步，看操作是否包含更新。如果完全没有更新，只有静态区间查询，优先想前缀和，别再考虑差分。第二步，如果存在大量区间更新，并且题目最后允许一次或少数几次查询，优先想差分。第三步，如果数组在被更新的过程中还需要频繁查询实时值，那就不是前缀和或差分能轻松搞定的事了，得换树状数组、线段树等数据结构。第四步，如果问题不是一维数组而是二维矩阵，把上面的判断逻辑各自升维：静态子矩阵查询用二维前缀和；大量矩形更新后输出最终矩阵用二维差分。

这套判断思路不是我发明的高级理论，它的本质是观察修改和查询的频率是否对称。你会发现前缀和与差分的组合使用特别适合“先囤积所有修改，再统一查询”的离线题目。很多做算法竞赛的朋友应该都遇到过一类题叫“离线修改 + 在线查询”，为了压缩常数，差分数组往往是最好的预处理手段。

我个人的体会是，千万别把前缀和、子矩阵、差分、差分矩阵当成四个孤立的公式背。它们其实是同一根链条上的四个齿轮：一维前缀和擅长区间求和，二维前缀和擅长矩形求和；差分是一维前缀和的逆运算，二维差分是二维前缀和的逆运算。先理解二维公式里的容斥来源，再看着边界多一格的数组设计，你不仅能快速写出模板，还能在出现错误时一眼看出问题在哪。

最后一个建议：遇到新题时别急着套模板，先在草稿上画几个格子，特别是有二维坐标的题，把要修改的矩形区域边界标出来，再对照四个点位有没有在 x2+1、y2+1 方向越界。很多同学不是想不到差分，而是画图时没把“加一”这个动作标出来，导致代码写出来边界错得毫无头绪。把这些细节都理顺之后，这套经典工具就彻底属于你了。