丞高在上一篇文章里，我们把一维前缀和的基本思想、标准模板和一些基础应用都过了一遍。如果你已经掌握了那部分内容，这篇“前缀和（2）”就可以放心往下看了。这篇要解决的是几个更进阶的问题：二维数组里的区间求和怎么做、前缀和的互补数据结构差分数组到底怎么用、以及面试题里那些“一看就知道要用前缀和”的套路长什么样。
这一篇更适合已经能独立写出第一种前缀和模板、但是面对二维数组或者需要“区间多次修改再查询”的题目时还没把握的读者。如果你正在准备算法面试，或者刷LeetCode、牛客、力扣的时候遇到了前缀和相关的中等题，这篇内容可以直接当作参考手册用。
1. 从一维到二维：二维前缀和到底解决了什么问题
1.1 为什么二维数组的区间求和不能继续用一维模板
先回顾一个最简单的场景：给你一个长度是 n 的数组，要求频繁查询某一段 [l, r] 的和。一维前缀和的做法很自然，预处理出一个 prefix 数组，prefix[i] 表示前 i 个元素的和，查询时直接用 prefix[r] - prefix[l-1] 得出结果。这个思路的核心是“用预处理换查询时间”。
但是当数据从一维数组变成二维矩阵之后，问题就变了。假设给你一个 m 行 n 列的矩阵，要求频繁查询某个子矩阵（第 r1 行到第 r2 行、第 c1 列到第 c2 列，行列范围都闭区间）内所有元素的和。最暴力的做法是每次查询都双重循环遍历这个子矩阵，单次查询的时间复杂度是矩阵面积的量级。如果查询次数很多，比如 10 万次查询、矩阵规模又很大，这种暴力求和基本上就宣告超时了。
有人会想：那我能不能对每一行都做一个一维前缀和，然后按行累加？可以，这样单次查询的复杂度会变成行数级别的，在行数比较少的时候是可行的。但一旦矩阵本身是正方形而且规模上千，这个方案还是会退化。真正的解法是用“二维前缀和”，把子矩阵和查询的时间复杂度压到 O(1)。
1.2 前缀和矩阵的构造公式与容斥原理
二维前缀和的定义其实是一维定义的直接推广。一个预处理好的二维前缀和数组 S，其中 S[i][j] 表示从矩阵左上角 (0,0) 到 (i,j) 这个矩形区域内所有元素的和。注意这里的边界是包含第 i 行和第 j 列的。
关键问题来了：怎么高效地构造出这个 S 数组？
如果你一个一个格子去累加，每个格子都重新从 (0,0) 加到 (i,j)，那预处理的复杂度就是 O(n^3)，完全失去意义。正确的做法是“递推”，用一个基于容斥原理的公式：
code复制S[i][j] = S[i-1][j] + S[i][j-1] - S[i-1][j-1] + A[i][j]
这里的 A[i][j] 是原始矩阵中第 i 行第 j 列的元素。这个公式怎么理解？S[i-1][j] 覆盖的是上方的矩形，S[i][j-1] 覆盖的是左方的矩形，但是这两个矩形重叠了左上角那块 S[i-1][j-1]，所以要减掉一次，最后再把当前格子的值加上。
容斥原理在算法题目里其实很常见。别把它想得多玄乎，其实和求两个集合的交并集是一个道理：A 集合人数加 B 集合人数，减去 A 和 B 都算了两次的人数，才能得到真正的并集人数。这里只是把这个想法用在了矩阵加法上。
1.3 查询任意子矩阵和的 O(1) 公式推导
预处理完 S 之后，查询就是套公式。我想求矩阵从 (r1, c1) 到 (r2, c2) 这个闭区间子矩阵的和，公式是：
code复制sum = S[r2][c2] - S[r1-1][c2] - S[r2][c1-1] + S[r1-1][c1-1]
这个公式同样可以通过画图来理解：先用 S[r2][c2] 拿到从原点到右下角整个矩形的和，然后把上面一行以上的区域减掉（S[r1-1][c2]），再把左边一列以左的区域减掉（S[r2][c1-1]）。这时左上角那块被减了两次的区域要加回来（S[r1-1][c1-1]），所以最后是这个样子。
实际编码的时候，一个常见的做法是让 S 数组的下标从 1 开始，也就是申请 (m+1) x (n+1) 的数组，第 0 行第 0 列全部置为 0。这样 r1-1 = 0 的情况直接取到 0，省掉了大量边界判断，代码既干净又不容易出错。这个技巧在算法竞赛和面试里几乎是约定俗成的。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 二维前缀和的 Java 实现与边界细节
2.1 经典模板代码（预处理 + 查询）
把上面的公式翻译成 Java 代码，一个完整的二维前缀和模板大概是这样的：
java复制public class PrefixSum2D {
private int[][] S;
private int rows;
private int cols;
// 预处理，matrix 是原始矩阵
public PrefixSum2D(int[][] matrix) {
rows = matrix.length;
cols = matrix[0].length;
S = new int[rows + 1][cols + 1];
for (int i = 1; i <= rows; i++) {
for (int j = 1; j <= cols; j++) {
S[i][j] = S[i - 1][j] + S[i][j - 1] - S[i - 1][j - 1] + matrix[i - 1][j - 1];
}
}
}
// 查询闭区间 [r1, c1] 到 [r2, c2] 的子矩阵和
public int query(int r1, int c1, int r2, int c2) {
// 这里传入的是原始矩阵的 0-based 行号列号
r1++;
c1++;
r2++;
c2++;
return S[r2][c2] - S[r1 - 1][c2] - S[r2][c1 - 1] + S[r1 - 1][c1 - 1];
}
}
注意上面代码里 query 的时候做了一个下标转换。如果你选择接口层面统一使用 0-based 坐标，那在方法内部转成 1-based 坐标即可。另一种常见做法是接口直接接收 1-based 坐标，这样省掉转换，但调用方更容易搞混。我个人建议对外统一用 0-based，内部用 1-based，这个约定在写复杂业务逻辑的时候能省掉很多不必要的误解。
2.2 从 0 开始还是从 1 开始：索引设计的坑
这个坑值得单独提出来说，因为我自己就踩过不只一次。二维前缀和一旦处理不好边界，很容易出现数组越界或者结果错误。
先说你直接套一维的思路，创建一个和原矩阵一模一样大小的 S 数组，然后写循环：
java复制for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
int up = (i > 0) ? S[i - 1][j] : 0;
int left = (j > 0) ? S[i][j - 1] : 0;
int upLeft = (i > 0 && j > 0) ? S[i - 1][j - 1] : 0;
S[i][j] = up + left - upLeft + matrix[i][j];
}
}
这个写法可以工作，但每行都要带着三个边界判断，代码观感很不好。尤其是在做竞速题的时候，边界一多，出错的概率就成倍增加。
换成一个 (rows + 1) 行 (cols + 1) 列、第 0 行第 0 列全是 0 的 S 数组之后，上面的三个 if 全部消失了。因为 S[i-1][j] 在 i=0 时取到第 0 行，值一定是 0；S[i][j-1] 在 j=0 时同理。这就是“多开一圈”的收益。在算法实现里，这种牺牲一点空间、换取代码简洁和逻辑统一的做法是非常划算的。
2.3 原地修改与空间优化思路
有些刷题老手可能会问：能不能在原矩阵上直接改，省掉 S 矩阵的空间？
严格来说是可行的。如果你不再需要原始矩阵，可以在传入的 matrix 数组上直接累加，改成前缀和矩阵：
java复制for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
int up = (i > 0) ? matrix[i - 1][j] : 0;
int left = (j > 0) ? matrix[i][j - 1] : 0;
int upLeft = (i > 0 && j > 0) ? matrix[i - 1][j - 1] : 0;
matrix[i][j] = up + left - upLeft + matrix[i][j];
}
}
这样就把空间复杂度从 O(mn) 降到了 O(1)（不考虑输入本身占用的空间）。但在实际开发场景里，我建议你谨慎使用原地修改，因为原始矩阵很可能后续还要用到。如果你真的想省空间，又不想丢原始数据，一个折中方案是把 S 数组声明为 long 类型避免溢出，因为这比原地修改带来的风险小得多。
顺带说一个很多教程不会提的点：当矩阵元素的值很大，或者子矩阵数量极多、求和结果可能超过 int 上限的时候，S 数组建议声明成 long[][] 而不是 int[][]。虽然 Java 的 int 最大能到 21 亿，但子矩阵求和动不动就是几个大数相加，累积起来很容易越界。LeetCode 上很多题目的测试数据不一定覆盖得到这种极端情况，但你自己心里要有数。
3. 前缀和的互逆操作：差分数组的实战价值
3.1 差分数组的本质：把区间加减变成两个点的修改
说完二维前缀和，现在把视野拉回一维。前缀和有一个非常紧密的“搭档”，叫差分数组。两者是互逆的关系：对原数组求差分，得到差分数组；对差分数组求前缀和，可以还原出原数组。
差分数组的定义很简单：diff[i] = nums[i] - nums[i-1]（i 从 1 开始）。diff[0] 直接等于 nums[0]。
但差分数组真正的价值不在定义，而在它的一个神奇性质：如果我想让原数组的某个连续区间 [l, r] 的所有元素同时加上一个值 val，不需要真的去遍历这个区间，只需要修改两个位置：
code复制diff[l] += val;
diff[r + 1] -= val;
为什么？因为差分数组只记录相邻元素的差值。diff[l] 增加 val 之后，在对差分数组做前缀和还原时，从下标 l 开始每个元素都会多出 val；为了不让这个影响延续到 r 之后，我们在 diff[r+1] 减去 val，把这个影响正好抵消掉。
生活化一点的类比：想象一排高度不同的积木，差分数组记录的是每一块积木比前一块高出多少。如果我想让第 3 到第 5 块积木同时加高 2 厘米，不需要一块一块去动它们，只需要在第 3 块底下垫高 2 厘米、第 6 块底下降低 2 厘米。第 3 到第 5 块相对前面的高度差变了，但从第 6 块开始，相对高度又恢复了原状。
3.2 Java 实现差分数组的模板
直接上一个能用的差分模板。假设 nums 是原始数组，diff 和 nums 长度一样（或者更长一位，为了处理 r+1 越界问题）：
java复制public int[] buildDifference(int[] nums) {
int n = nums.length;
int[] diff = new int[n + 1];
diff[0] = nums[0];
for (int i = 1; i < n; i++) {
diff[i] = nums[i] - nums[i - 1];
}
// diff[n] 留作 0，用于区间操作的 r+1 落点
return diff;
}
// 对区间 [l, r] 增加 val，闭区间
public void rangeAdd(int[] diff, int l, int r, int val) {
diff[l] += val;
diff[r + 1] -= val;
}
// 从差分数组还原原数组
public int[] restoreFromDiff(int[] diff) {
int n = diff.length - 1;
int[] nums = new int[n];
nums[0] = diff[0];
for (int i = 1; i < n; i++) {
nums[i] = nums[i - 1] + diff[i];
}
return nums;
}
这里 diff 数组申请了 n+1 长度，就是为了给 r + 1 留一个位置。当 r 恰好是数组最后一个元素的下标时，diff[r+1] 落在哨兵位置上，不影响还原出来的数组长度，也省去了越界判断。这个思路和二维前缀和里“多开一圈”如出一辙——都是通过空间冗余换来代码简洁和边界安全。
3.3 前缀和与差分的组合套路：区间多次操作后查询
差分数组最经典的实战场景，是“先进行大量区间修改，最后再做查询”的题目。为什么快？因为区间修改本身从 O(n) 降到了 O(1)（只动两个点），所有修改做完之后，只需一次线性扫描把差分数组还原成原数组，就能拿到最终结果。整个过程的时间复杂度是 O(n + k)，k 是区间修改次数。相比之下，暴力修改的时间复杂度是 O(n * k)，当 k 和 n 都很大的时候，两者差距是指数级的。
举一个很典型的应用场景：你有一个长度为 n 的全 0 数组，接下来有 k 次操作，每次操作在 [l, r] 区间内所有元素加上一个特定值，最后要输出数组中每个位置的值。这个场景在 LeetCode 上有原题叫“航班预订统计”，面试出现频率不低。
解题思路就是：初始化一个长度为 n+2 的差分数组（多两个位置防止 r+1 越界），对每次操作调用 rangeAdd，所有操作结束后做一次前缀和还原，输出结果。不需要高级数据结构的参与，差分数组就是最朴素也最高效的解法。
我之前在项目里处理过一个类似的场景：给一批用户打标签，标签是按序号的连续区间批量打的，打完标签后要统计每个编号被打了多少次。一开始同事用循环逐个累加，跑了将近十秒；换成差分数组之后瞬间出结果，而且代码量还更少。这就是差分的现实价值。
4. 面试题里最常见的四种前缀和套路
4.1 和为 K 的子数组：哈希表优化的关键
这道题是前缀和面试题中的“扛把子”，原题是 LeetCode 560。题目：给定一个整数数组 nums 和一个整数 k，请统计并返回数组中和为 k 的连续子数组的个数。
最暴力的做法是枚举所有起终点，O(n^2) 求和判断。但要过大数据量测试，必须用优化版本。思路是利用前缀和加上哈希表。
先想一个关键问题：连续子数组的和怎么用前缀和表示？如果 prefix[i] 表示前 i 个元素的和，那么从下标 j 到下标 i 的连续子数组和为 prefix[i] - prefix[j-1]（或者更自然地用 0-based 前缀和表示）。我们要找的是 prefix[i] - prefix[j] == k，也就是 prefix[j] == prefix[i] - k。
于是思路就清晰了：遍历 i 的时候，我们想知道之前出现过多少个前缀和等于 prefix[i] - k，把这些次数累加到答案里。为了快速获得这个次数，用一个哈希表记录每个前缀和值出现的次数。
java复制public int subarraySum(int[] nums, int k) {
// key: 前缀和, value: 出现次数
Map<Integer, Integer> map = new HashMap<>();
map.put(0, 1); // 空数组的前缀和是 0，出现一次
int sum = 0;
int count = 0;
for (int num : nums) {
sum += num;
count += map.getOrDefault(sum - k, 0);
map.put(sum, map.getOrDefault(sum, 0) + 1);
}
return count;
}
很多人看完代码会问：为什么要先 map.put(0, 1)？因为当 sum == k 时，sum - k == 0，代表从数组开头到当前位置这一段本身就是满足条件的子数组，所以前缀和 0 要预先记一次。这个初始化的细节忘了的话，代码会在“从 0 开始的子数组”这一类用例上出错。
时间复杂度 O(n)，空间复杂度 O(n)。这种“前缀和 + 哈希表”的组合套路在很多变体题里都会重复出现，比如统计和为 k 的最短子数组、统计和为 k 的倍数的子数组数量等，核心都是这个思路。
4.2 所有奇数长度子数组的和
这是 LeetCode 1588 的题目，看起来不像前缀和题，但前缀和就是最直观的解法之一。题目要求返回所有长度为奇数的子数组的和。
如果你套用“前缀和 + 枚举起点终点”的框架，代码是这样的：
java复制public int sumOddLengthSubarrays(int[] arr) {
int n = arr.length;
int[] prefix = new int[n + 1];
for (int i = 1; i <= n; i++) {
prefix[i] = prefix[i - 1] + arr[i - 1];
}
int total = 0;
for (int start = 0; start < n; start++) {
for (int len = 1; start + len <= n; len += 2) {
int end = start + len - 1;
total += prefix[end + 1] - prefix[start];
}
}
return total;
}
这个解法的复杂度是 O(n^2) 的。如果面试官进一步要求更优解，可以走数学规律，统计每个元素出现在多少个奇数长度子数组中，复杂度降到 O(n)。但我不建议一上来就秀数学，先拿出前缀和的解法说明思路，再往下优化，这个递进过程在面试里是加分项。
4.3 二维前缀和变体：最大子矩阵和
一维最大子数组和可以用 Kadane 算法解决，但最大子矩阵和就不一样了。LeetCode 363（不超过 K 的最大子矩阵和）和经典题“最大子矩阵和”都可以用“枚举上下边界 + 一维压缩 + 一维前缀和”的组合思路来做。
核心技巧是把二维问题压缩成一维。枚举矩阵的上边界 top 和下边界 bottom，在这两条边界之间，按列求和生成一个一维数组 colSum，其中 colSum[j] 表示第 top 行到第 bottom 行之间第 j 列的元素和。然后只要求 colSum 数组的最大子数组和即可。
这个思路本身不是二维前缀和，但如果你需要快速获取每列在某个行区间内的和，可以用每一列的一维前缀和来加速：colSum[j] = prefixPerColumn[bottom+1][j] - prefixPerColumn[top][j]。这就把二维前缀和中的思想用到了极限。
4.4 前缀和与同余定理的结合
再分享一类容易让人懵的题：给定一个整数数组和一个整数 k，判断是否存在一个连续子数组的和是 k 的整数倍。这类题的特点是，为了判断倍数的关系，不需要精确知道前缀和的值，只需要知道前缀和对 k 取模的结果。
原理是同余定理：如果两个前缀和 prefix[i] 和 prefix[j] 对 k 取模的结果相同，那么 prefix[i] - prefix[j] 一定是 k 的倍数。而这个差值恰好就是区间 [j+1, i] 的子数组和。所以解法很清晰：用一个哈希表记录“模 k 得到的余数首次出现的下标”，遍历前缀和时检查当前余数是否已经在表里。
java复制public boolean checkSubarraySum(int[] nums, int k) {
Map<Integer, Integer> map = new HashMap<>();
map.put(0, -1); // 余数 0 在 -1 位置出现，表示从头开始
int sum = 0;
for (int i = 0; i < nums.length; i++) {
sum += nums[i];
int mod = ((sum % k) + k) % k; // 处理负数
if (map.containsKey(mod)) {
if (i - map.get(mod) >= 2) return true;
} else {
map.put(mod, i);
}
}
return false;
}
注意这里 map.put(0, -1) 的含义：前缀和为 0 的情况在数组开始之前就存在，位置记为 -1。这样才能正确处理“子数组从下标 0 开始”的用例。此外，Java 的取模对于负数结果是负数，所以要用 ((sum % k) + k) % k 把结果转成正数。这类题在 LeetCode 上是 523，面试里也偶尔出现，值得掌握。
5. 综合案例：一次区间调度题中的前缀和与差分配合
5.1 题目描述与原理解读
讲一个我自己在处理内部工具时遇到的近似问题。假设有一批任务，每个任务有一个开始时间和结束时间（整数表示的时间点），并且每个任务会请求一个共享资源。这个共享资源在同一时间点只能执行固定数量的并发任务。现在要判断给定的任务序列是否可行，也就是每个时间点的并发任务数是否超过上限。
原始数据大概长这样：
code复制任务编号 开始时间 结束时间
0 1 3
1 2 5
2 4 6
3 7 8
这个需求本质上就是一个区间叠加问题。每个任务对应一个区间 [start, end]（这里是闭区间还是开区间要看具体业务），我们需要知道每个时间点被多少个区间覆盖。最直接的解法是遍历每个时间点，然后检查所有区间是否覆盖它，这就是 O(时间范围 * 任务数)，但一旦时间范围很大，这个做法就完全不可行。
这正是一个标准的前缀和 + 差分数组的应用场景。因为任务区间是提前知道的、而且只会一次性加进来，不需要实时动态更新，所以用差分数组做区间增量、最后用前缀和还原覆盖次数，是效率最高也最清晰的方案。
5.2 用差分数组实现区间操作、用前缀和恢复结果
假设时间点范围是 1 到 T，我们申请一个长度为 T+2 的差分数组 diff，下标从 1 开始，多出的 1 个位置留给 end+1 做变动。
对每个任务（startTime, endTime）：
java复制diff[startTime] += 1;
diff[endTime + 1] -= 1;
所有任务处理完之后，创建覆盖次数数组 cover：
java复制int[] cover = new int[T + 1];
int running = 0;
for (int t = 1; t <= T; t++) {
running += diff[t];
cover[t] = running;
}
这里 running 就是 diff 数组的前缀和，还原出的是每个时间点的任务覆盖数量。然后遍历 cover 数组，检查是否超过资源上限即可。
我初版代码跑出来一次通过，数据规模是 10 万任务、时间范围 100 万，整个过程不到一毫秒。如果是暴力遍历，哪怕用上了位运算优化，在这种规模下估计也要好几秒。这个差距在实时调度系统里是非常致命的。
5.3 复杂度对比与实测心得
把暴力方案和差分方案在同一个数据规模下做个对比：
| 方案 | 预处理时间复杂度 | 单次/总查询复杂度 | 空间复杂度 |
|---|---|---|---|
| 暴力遍历每个时间点检查所有区间 | 无 | O(T * n) | O(T) |
| 每行一维前缀和 | O(n * T) | 行数级 | O(n * T) |
| 差分数组 + 前缀和还原 | O(n) | 初始化无查询，还原 O(T) | O(T) |
实测下来，在任务数 10 万、时间范围 100 万的情况下：
- 暴力方案耗时大约 3 秒到 4 秒；
- 每行一维前缀和方案需要额外存储 10 万 x 100 万的矩阵，空间直接爆炸，根本不可行；
- 差分数组方案耗时 1 毫秒以内，空间占用也只有一两个数组。
这个案例给我最大的感受是：很多看起来复杂的业务问题，本质上就是给定若干区间、做批量区间加法、再求最终状态的“区间覆盖统计”问题。这类问题和前缀和、差分是天生一对。所以遇到区间操作类的需求，先别急着逐点遍历，想一下能不能转换成差分数组的两个端点修改，往往能带来数量级上的提升。
另外还有一个非常实用的调试技巧：你自己写差分数组代码的时候，如果结果不对，先把 diff 数组还原成原数组打印出来，和暴力结果对拍一下，定位是端点位置写错了还是边界条件没处理对。我见过不少人（包括我自己）在闭区间和开区间、以及是否 end+1 这类细节上翻车，一个系统性的对拍习惯能帮你快速排除问题，而不是盯着代码干瞪眼。
6. 二维前缀和的变体题目：从“求和”到“统计数量”
6.1 二维矩阵中的目标值子矩阵计数
前面讲二维前缀和，主要集中在“求某个子矩阵的和”这个功能上。但面试题往往不会只考这种裸功能，常见的升级方向是“统计满足条件的子矩阵个数”。
比如 LeetCode 1074：给定一个矩阵和一个目标值 target，返回元素总和等于目标值的非空子矩阵数量。这个题如果直接暴力枚举所有子矩阵的上下左右边界，再用二维前缀和快速求出每个子矩阵的和，时间复杂度是 O(m^2 * n^2)，m 和 n 是矩阵的行列数。这个复杂度在矩阵较小的时候可以接受，但稍微规模大一点就过不了。
高效的解法是把二维问题化成一维：枚举上下边界，把每一列在上下边界内的和压缩成一个一维数组，然后问题就变成了第 4 节讲的“和为 K 的子数组”问题，用前缀和加哈希表解决。
java复制public int numSubmatrixSumTarget(int[][] matrix, int target) {
int m = matrix.length;
int n = matrix[0].length;
int result = 0;
for (int top = 0; top < m; top++) {
int[] colSum = new int[n];
for (int bottom = top; bottom < m; bottom++) {
for (int j = 0; j < n; j++) {
colSum[j] += matrix[bottom][j];
}
result += subarraySumIn1D(colSum, target);
}
}
return result;
}
private int subarraySumIn1D(int[] nums, int k) {
Map<Integer, Integer> map = new HashMap<>();
map.put(0, 1);
int sum = 0;
int count = 0;
for (int num : nums) {
sum += num;
count += map.getOrDefault(sum - k, 0);
map.put(sum, map.getOrDefault(sum, 0) + 1);
}
return count;
}
这个解法的时间复杂度降到了 O(m^2 * n)，其中 m 是行数、n 是列数。如果你通过固定行数范围，再把列数较大的那个维度用哈希表优化，有时候还能进一步降。但这个思路已经足够应付大多数面试场景了。
6.2 二维差分数组的扩展
既然二维有前缀和，那二维自然也有差分。二维差分解决的问题是：在一个矩阵上频繁做矩阵区域的加法操作，所有操作做完之后查询最终矩阵。
一维差分的核心操作是在两个端点修改，二维差分则是在四个角落修改。假设我们要把一个子矩阵 (r1, c1) 到 (r2, c2) 区域内的所有元素加 val，差分数组的操作是：
code复制diff[r1][c1] += val;
diff[r1][c2 + 1] -= val;
diff[r2 + 1][c1] -= val;
diff[r2 + 1][c2 + 1] += val;
最后通过对二维差分矩阵做二维前缀和，就能还原出最终的矩阵。理解这个公式的关键还是容斥原理：在一个点加 val 之后，二维前缀和会让这个点右下方的整个区域都加 val，所以需要用另外三个点来抵消掉多余的部分。
二维差分在实际编程中比一维要少见一些，但一旦遇到矩阵区域批量更新的题目，它几乎总是最优解。建议你在掌握了二维前缀和之后，顺手把二维差分的代码也写一遍，思路和公式吃透。
7. 从“能用”到“好用”：Java 实现中的效率与代码风格
7.1 避免自动装箱带来的时间损耗
写 Java 算法题的时候，很多人习惯直接用 HashMap<Integer, Integer> 做统计，这本身没问题。但在数据量很大的情况下，自动装箱（int 转 Integer）会带来额外的对象创建开销。如果性能卡得很紧，可以考虑用 IntIntHashMap 这类第三方库，或者自己实现一个简单的数组法哈希表，用两个数组分别存 key 和 value，线性探测法处理冲突。
java复制// 一个极简的 int->int 哈希表示例，仅作思路参考
class IntIntMap {
private int[] keys;
private int[] values;
private int capacity;
private int size;
public IntIntMap(int capacity) {
this.capacity = capacity;
keys = new int[capacity];
values = new int[capacity];
Arrays.fill(keys, Integer.MIN_VALUE);
}
public void put(int key, int value) {
int idx = (key & 0x7fffffff) % capacity;
while (keys[idx] != Integer.MIN_VALUE && keys[idx] != key) {
idx = (idx + 1) % capacity;
}
if (keys[idx] == Integer.MIN_VALUE) size++;
keys[idx] = key;
values[idx] = value;
}
public int get(int key) {
int idx = (key & 0x7fffffff) % capacity;
while (keys[idx] != Integer.MIN_VALUE) {
if (keys[idx] == key) return values[idx];
idx = (idx + 1) % capacity;
}
return 0;
}
}
这个优化在 LeetCode 的大数据用例上经常能明显减少运行时间。但如果不是竞赛场景，我其实不太建议为了这一点性能牺牲可读性。先写出清晰的 HashMap 版本，通过了再考虑优化，这是更稳妥的开发思路。
7.2 能过测试和能上生产是两回事
这是我想强调的一点。算法题里的前缀和模板，和真实项目里的前缀和代码，之间还隔着一层“边界意识”。
真实项目的数组可能是空数组，矩阵可能是 0 行 m 列或者是 m 行 0 列，需要在构造前缀和数组之前先判断。真实项目的输入不一定是一口气给完的，可能是动态追加的，每次追加一行或几行数据，需要动态扩容并维护前缀和信息，这在 LeetCode 的静态输入题目里不会出现，但业务里非常常见。
如果你把算法模板直接搬到生产代码里，大概率会出问题。至少要在开头加上这类防御性判断：
java复制public PrefixSum2D(int[][] matrix) {
if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
return;
}
// 后续初始化逻辑
}
另外，如果数据量特别大，前缀和数组可能会超过 int 的范围，前面说过要用 long。这个在测试用例里可能不会触发，但线上数据一上去就暴露出来了。
7.3 怎么系统化训练前缀和这个专题
如果你想把前缀和相关的内容彻底吃透，我建议按下面的顺序自己刷一遍题目。每道题做完之后，都要在笔记里写下“为什么这道题可以用前缀和”以及“核心优化点是什么”，只有能讲出这两点，才算真正会了。
- 一维前缀和裸题（LeetCode 303：区域和检索 - 数组不可变）
- 差分数组入门（LeetCode 370：区间加法，会员题）
- 前缀和加哈希表（LeetCode 560：和为 K 的子数组）
- 二维前缀和（LeetCode 304：二维区域和检索 - 矩阵不可变）
- 前缀和与同余（LeetCode 523：连续的子数组和）
- 二维前缀和加哈希表（LeetCode 1074：元素和为目标值的子矩阵数量）
- 二维差分扩展（LeetCode 2536：子矩阵元素加 1）
这里面每一道题做完，都建议先用暴力解法对拍一下，确认正确性，再去思考怎么优化。不要一上来就想着最优解，先保证自己的基础实现是对的，然后在这个基础上一层层把“冗余计算”替换成前缀和、差分、哈希表，这样理解会深刻得多。
根据我自己的经验，大约认真做完这七八道题，前缀和和差分的常见题型见一遍、思路过一遍，面试里遇到相关题目就不会慌。而且这些题型的核心思路是相通的：第一步识别出连续区间求和或批量区间叠加的模式，第二步决定用前缀和还是差分，第三步套模板、处理边界，最后再根据题目要求做一点变化。
前缀和和差分这两个工具，单独看都挺简单，但组合起来能解决一大类问题。多写几道题之后，你对“区间操作”这类题目的敏感度会明显提升，看一道题你能下意识地判断出这题是不是前缀和的套路。这种敏感度，靠的正是反复练习和总结，而不是看几篇教程就能获得的。