前缀和与差分数组全解：从一维到二维，LeetCode高频套路实战

前缀和这东西，说实话，属于那种“看着简单、用起来真香、但一深挖全是细节”的算法技巧。我在LeetCode上刷了几百道题之后回头看，前缀和和差分这对组合，几乎就是处理区间求和、子数组目标值、二维矩阵统计这类题型的万能钥匙。很多人觉得它简单，无非就是 pre[i] = pre[i-1] + nums[i]，但真到了题目变化的时候，还是容易卡在“怎么想到用前缀和”“映射关系怎么处理”“边界条件怎么定”这些地方。这篇专题我打算系统拆一拆前缀和的底层逻辑和实战套路，带你把这类题吃透，而不是只会背模板。

这篇文章适合几类人看：刚开始刷LeetCode、被“子数组”“区间和”绕晕的新手；已经会写一维前缀和但二维、哈希表配合这些变体还没理清的选手；以及面试前想快速过一遍高频套路、准备周赛和热门100题的老手。内容会覆盖从最朴素的暴力解法到前缀和优化、再到前缀和与哈希表的经典组合，中间穿插LeetCode真题拆解和实操踩坑记录，尽量让你看完就能上手用。

1. 前缀和的思想拆解：为什么它能把 O(n²) 降到 O(1)

1.1 从求和问题出发：暴力的痛点在哪里

先聊一个最基础的场景：给你一个数组，频繁询问某个区间 [l, r] 的元素和。比如 nums = [1, 2, 3, 4, 5]，你就随便问，1到3下标之间的和是多少、0到4下标之间的和是多少。最直接的想法就是遍历区间累加，每次查询的复杂度是 O(区间长度)，如果数组长度是 n、有 m 次查询，总复杂度就是 O(m·n)。

这个复杂度在数据量小的时候无所谓，但 LeetCode 上这类题的特点通常都是：数组很长、查询次数很多，暴力解法必定超时。我自己最开始刷题的时候就不止一次踩过这个坑——写了个两层循环觉得挺美，一提交直接超时，原因就是每次查询都重新把区间扫一遍，大量的重复计算被白白浪费了。

1.2 前缀和的数学本质：把求和变成一次减法

前缀和的核心思想是预处理。我们定义 pre[i] 表示数组前 i 个元素的和（注意这里说的是“前 i 个”，也就是说 pre[0] = 0，pre[1] = nums[0]，pre[i] = nums[0] + nums[1] + ... + nums[i-1] 这种写法）。

于是区间 [l, r] 的和就可以用一个非常漂亮的公式算出来：

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

为什么会这样？你想象一下：pre[r+1] 是前 r+1 个元素的总和，pre[l] 是前 l 个元素的总和，两者一减，中间剩下的正好就是下标 l 到 r 这段的元素和。这个过程本质上就是把连续求和转化成一次减法，所以预处理完之后，每次查询的耗时是 O(1)。

你可以把 pre 数组理解成一条“累计水位线”：每到一个位置，水位线就记录下从起点流到这里的总水量。想知道中间某一段流了多少水，用下游水位减上游水位就行了。这个类比虽然简单，但我每次跟别人讲前缀和都爱用，因为它能帮你建立直觉。

1.3 前缀和的核心优势与适用边界

前缀和使用的前提是：数组是静态的，或者说查询次数远大于修改次数。如果数组的元素要频繁更新，那前缀和就要跟着重建，反而不如树状数组或线段树灵活。这是很多新手容易忽略的点——不是所有求和问题都无脑上前缀和，你得先判断数据是“只读”还是“频繁写”。

它的适用场景我总结下来有三个典型方向：

• 静态数组的区间求和查询
• 需要快速判断某个子数组和是否满足一定条件
• 二维矩阵中的矩形区域统计

如果题目里出现了“连续子数组”“区间和”“子矩阵和”这些关键词，前缀和几乎是可以最先尝试的方向之一。它不是万能药，但在这些场景下往往是最简单、最不易错的方案。

2. 一维前缀和的模板与LeetCode实战：从 303 题开始

2.1 基础模板：一维数组前缀和的两种写法

先把一维前缀和的标准代码写出来，我用 Python，因为 LeetCode 上写 Python 的人最多，而且代码接近伪代码，方便记成模板。

写法一：pre 数组长度比 nums 多一位，pre[0] = 0。

python复制class PrefixSum:
    def __init__(self, nums):
        self.pre = [0] * (len(nums) + 1)
        for i in range(len(nums)):
            self.pre[i+1] = self.pre[i] + nums[i]
    
    def query(self, l, r):
        return self.pre[r+1] - self.pre[l]

写法二：pre 和 nums 长度一致，pre[i] 表示前 i+1 个元素的和。

python复制class PrefixSum2:
    def __init__(self, nums):
        self.pre = [0] * len(nums)
        s = 0
        for i, x in enumerate(nums):
            s += x
            self.pre[i] = s
    
    def query(self, l, r):
        if l == 0:
            return self.pre[r]
        return self.pre[r] - self.pre[l-1]

两种写法都能用，但我个人强烈推荐第一种，也就是 pre[0] = 0 的写法。它的好处非常明显：查询的时候不需要特判 l == 0 的情况，边界统一用 pre[r+1] - pre[l] 就完事了，少一个分支就少一个出错的机会。这是我刷了几十道前缀和题之后的切身体会，别嫌这点细节烦，边界条件处理好了能帮你省下大量调试时间。

2.2 LeetCode 303 区域和检索：一道标准的“填空题”

LeetCode 303 题“区域和检索 - 数组不可变”就是直接套模板的题，题目要求：给定一个整数数组 nums，处理多个查询，每次查询返回 nums[i] 到 nums[j] 的和，且数组不可变。

这道题就是给前缀和模板量身定做的。构造函数里预处理 pre 数组，sumRange 方法里直接返回 pre[right+1] - pre[left] 即可。完整代码：

python复制class NumArray:
    def __init__(self, nums):
        self.pre = [0] * (len(nums) + 1)
        for i in range(len(nums)):
            self.pre[i+1] = self.pre[i] + nums[i]

    def sumRange(self, left: int, right: int) -> int:
        return self.pre[right+1] - self.pre[left]

我第一遍做这道题的时候还想着用切片 sum(nums[left:right+1])，一提交，超时。后来才意识到题目要求的是多次查询，每次都切片求和等于每次都白白遍历区间，数据量一大必挂。这道题的价值不在于难，而在于帮你建立一个意识：看到“多次查询区间和”，第一反应就应该是预处理换时间。

2.3 变体练习：和为 K 的子数组（LeetCode 560）

如果说 303 是模板题，那 LeetCode 560 就是前缀和真正开始“秀操作”的题。题目是：给你一个整数数组 nums 和一个整数 k，统计有多少个连续子数组的和等于 k。

这道题我第一次看到的时候第一反应是暴力枚举左右端点，复杂度 O(n²)，数据范围一大就超时。后来才意识到前缀和 + 哈希表才是正解。

关键思路是这样的：用前缀和 pre[i]，那么子数组 nums[j..i] 的和为 pre[i+1] - pre[j]。题目要求这个和等于 k，也就是 pre[i+1] - pre[j] = k，移项得到 pre[j] = pre[i+1] - k。

这就变成了一件很有趣的事：我们遍历到某个位置 i 时，只需要知道在之前所有位置中，前缀和等于 pre[i+1] - k 的个数有多少个，这些位置作为 j，对应的子数组和就是 k。

于是我们可以用一个哈希表来统计每个前缀和出现的次数，遍历一遍数组，边更新前缀和边查表，时间复杂度直接降到 O(n)。

python复制def subarraySum(nums, k):
    from collections import defaultdict
    count = defaultdict(int)
    count[0] = 1  # 前缀和为0出现一次，表示从开头到当前元素
    pre = 0
    res = 0
    for x in nums:
        pre += x
        res += count[pre - k]
        count[pre] += 1
    return res

这一段代码里有几个细节非常值得琢磨：

• 为什么 count[0] 初始化为 1？因为如果当前前缀和恰好等于 k，那 pre - k = 0，说明从数组开头到当前位置的整段子数组都满足条件，这个解必须被统计进去，所以前缀和 0 要预置为出现 1 次。
• 为什么先查表再加当前前缀和？因为我们要找的是“之前出现过的位置”，不能把自己当前的 pre 算进去，否则会出现长度为 0 的子数组被错误统计的情况。这个顺序问题我亲眼见过很多人在评论区栽跟头，自己也犯过。

2.4 同类题扩展：连续子数组和为 k 的倍数的变体

LeetCode 523 题“连续的子数组和”跟 560 很像，但条件变成了“是否存在连续子数组，其和为 k 的倍数，且子数组长度至少为 2”。这就要用到前缀和取模的思想。

核心公式是：如果 pre[j] % k == pre[i] % k（其中 j > i），那么子数组 nums[i..j-1] 的和就是 k 的倍数。原理很简单，两个前缀和对 k 同余，说明它们之间的差是 k 的倍数。

举个例子，nums = [23, 2, 4, 6, 7]，k = 6。前缀和依次是 23、25、29、35、42，对 6 取模得到 5、1、5、5、0。其中下标 0 和下标 2 的模数都是 5，说明 nums[1..2] 的和 2+4=6 是 6 的倍数。

这道题的代码可以这么写：

python复制def checkSubarraySum(nums, k):
    seen = {0: -1}
    pre = 0
    for i, x in enumerate(nums):
        pre = (pre + x) % k
        if pre in seen:
            if i - seen[pre] >= 2:
                return True
        else:
            seen[pre] = i
    return False

注意这里哈希表存的是第一次出现某个模数的下标，而且初始化 seen = {0: -1} 表示前缀和为 0 的位置在 -1（也就是没有元素时）。这样做是为了处理从下标 0 开始的子数组。同时还要保证子数组长度至少为 2，所以当遇到相同模数时要检查下标差。这道题在 LeetCode 周赛和面试中出现频率不低，是一道把前缀和和同余定理结合得很巧妙的题目。

3. 二维前缀和：从一维升级到矩阵，LeetCode 304 实战拆解

3.1 二维前缀和的定义与递推关系

一维我们搞定了，接下来就是二维。二维前缀和解决的问题是：给定一个二维矩阵，多次查询某个矩形区域内所有元素的和。它是怎么做的呢？定义 pre[i][j] 表示从矩阵左上角 (0, 0) 到 (i, j) 这个范围内所有元素的和，注意这里我为了代码简洁可以直接用 pre[i+1][j+1] 对应原矩阵前 i+1 行前 j+1 列的总和，这种“多开一行一列”的写法可以省掉边界判断。

它的递推公式长这样：

pre[i+1][j+1] = pre[i][j+1] + pre[i+1][j] - pre[i][j] + matrix[i][j]

这个公式很多人第一次看会懵，我拆开讲：要计算以 (0,0) 为左上角、(i,j) 为右下角的矩形和，它等于“去掉当前行之前的区域和”加上“去掉当前列之前的区域和”，但这两个区域交叠了左上角那块 (0,0) 到 (i-1,j-1) 的区域，多算了一次，所以减掉，最后再加上 matrix[i][j] 这个元素本身。

你可以把它想象成在纸上画两个重叠的矩形，重叠部分需要扣掉一次。这个“容斥”的思想其实贯穿了整个二维前缀和的计算和查询过程，理解了它，后面的查询公式也就顺手理解了。

3.2 矩形区域查询公式与容斥原理

查询某个矩形区域 [r1, c1] 到 [r2, c2] 的和，公式是：

sum = pre[r2+1][c2+1] - pre[r1][c2+1] - pre[r2+1][c1] + pre[r1][c1]

同样用容斥来理解：先取左上角 (0,0) 到 (r2,c2) 的总和，减去上面多出来的行区域，减去左边多出来的列区域，但左上角那块被减了两次，所以要加回来一次。

我建议你画一个 3x3 的格子图，把 pre 的每个格子标注出来，手动推一遍查询公式。这个方法比干看公式一百遍都管用，我在学习这一步的时候就是这么干的，推完就再也不会忘。

3.3 LeetCode 304 完整实现与模板代码

LeetCode 304 题“二维区域和检索 - 矩阵不可变”就是二维前缀和的直接应用。题目给的 matrix 不会变，查询的时候直接用公式计算。

python复制class NumMatrix:
    def __init__(self, matrix):
        m, n = len(matrix), len(matrix[0])
        self.pre = [[0] * (n + 1) for _ in range(m + 1)]
        for i in range(m):
            for j in range(n):
                self.pre[i+1][j+1] = self.pre[i][j+1] + self.pre[i+1][j] - self.pre[i][j] + matrix[i][j]
    
    def sumRegion(self, row1: int, col1: int, row2: int, col2: int) -> int:
        return self.pre[row2+1][col2+1] - self.pre[row1][col2+1] - self.pre[row2+1][col1] + self.pre[row1][col1]

这个模板的关键点就是：pre 矩阵两个维度都多开一位，而且是 (m+1) x (n+1)，让 pre[0][] 和 pre[][0] 全为 0。这样构造和查询都不用特判边界，代码会非常干净。

我自己写这道题时踩过一个典型的坑：一开始想省内存，直接用和 matrix 一样尺寸的 pre 数组，结果在 sumRegion 里要各种判断 row1 == 0、col1 == 0 的情况，代码写了一堆 if，还容易算错。后来改成多开一行的模板写法，一个 if 都不用写了。这个教训让我之后写任何二维前缀和题都直接用这个模板，不再自找麻烦。

3.4 二维前缀和的进阶场景：矩形区域内的统计

二维前缀和不光能求区域和，还可以配合其他技巧处理更复杂的统计问题。比如 LeetCode 363 题“矩形区域不超过 K 的最大数值和”，就是二维前缀和配合二分搜索的经典题目。

那道题的思路是：先枚举矩形的上下边界，然后在这个上下边界固定的情况下，把二维问题压成一维问题——把每一列的和算出来，形成一个一维数组，再用一维前缀和 + 有序集合（比如 Python 的 bisect）来查找是否存在某个前缀和使得区域和不大于 K。

这里涉及两个维度的时间复杂度，如果矩形是 m 行 n 列，枚举上下边界是 O(m²)，每个边界下对列做处理是 O(n)，再加上有序集合查找是 O(log n)，总复杂度是 O(m²·n·log n)，在题目给出的数据范围内是可以接受的。

这类题其实就是在提醒你：前缀和是一个基础工具，它经常要和二分、哈希表、滑动窗口等其他工具配合使用，单独拿出来只是入门，组合起来才是面试真正考察的东西。

4. 前缀和与哈希表的组合拳：高频面试题的通用套路

4.1 为什么哈希表能让前缀和“活”起来

光有前缀和数组，能解决的问题其实有限——主要就是区间求和查询。一旦题目变成“统计有多少个子数组满足某某条件”，单纯的 pre 数组就不够用了，因为枚举左右端点的复杂度是 O(n²)，还是要超时。

这时哈希表就该登场了。核心思想我前面在 560 题里已经演示过：把前缀和的值存进哈希表，键是前缀和的值，值是这个前缀和出现的次数（或者第一次出现的位置、最后一次出现的位置，取决于题目要求）。这样在遍历数组的过程中，我们就能用 O(1) 的时间“回头看”之前是否出现过满足条件的前缀和。

一句话总结这个套路：

遍历前缀和时，把问题转化为“查找之前出现过的某个值”，哈希表提供 O(1) 的查询能力，配合前缀和把 O(n²) 暴力降到 O(n)。

我刷了这么多题，越来越觉得这个套路才是前缀和真正的核心价值。很多看起来很难的题，本质上都是这个套路的包装和变形。

4.2 “目标和”类问题的通用分析框架

LeetCode 494 题“目标和”的热度也很高。题目是这样的：给你一个非负整数数组 nums 和一个整数 target，你可以给每个数组元素前面添加 + 或 - 号，计算一共有多少种不同的方案使得所有元素符号化之后的和等于 target。

这道题的标准解法是动态规划，但如果你用前缀和 + 哈希表的视角去理解，会有另一种启发。设所有添加正号的元素和为 P，所有添加负号的元素和为 N，那么有 P + N = sum(nums)，P - N = target，联立可得 P = (sum(nums) + target) / 2。问题就转化为：在数组中找到若干个元素，使得它们的和为 P，求方案数。这正是经典的“子集和”问题，可以转化为 0-1 背包或 DP。

那前缀和在这个问题里有什么作用呢？它主要体现在对子数组和、子集和的快速转换思维上。虽然 494 本身不是前缀和的典型应用，但这类“把条件等式转化为目标值查找”的思想是通用的。你在一维数组上遇到“和为 target 的子数组”，就用 560 题的哈希表套路；你遇到“选若干元素凑成 target”，就用 DP 或背包。前缀和主要覆盖前一种。

我在整理这类题的时候习惯画一个思维导图：

• 连续子数组 + 和 = k → 前缀和 + 哈希表记录出现次数
• 连续子数组 + 和 % k = 0 → 前缀和 + 哈希表记录模数第一次出现的位置
• 连续子数组 + 和不小于 k 的方案数 → 前缀和 + 平衡树/离散化 + 树状数组（高级版）
• 矩阵矩形区域 + 和条件 → 二维前缀和 + 枚举边界压成一维

你会发现，前缀和只是一把钥匙，真正拉开差距的是你能不能根据题目条件选择合适的“锁芯”。这个表我建议你自己整理一遍，比直接抄别人的总结有效得多。

4.3 LeetCode 437 路径总和 III：前缀和在树上的惊艳应用

LeetCode 437 题是一道二叉树上的前缀和历史经典题。题目要求统计从任意节点到其子节点的路径中，路径和等于 targetSum 的路径条数。注意路径方向必须是向下的（从父节点到子节点）。

刚开始刷树的题时，看到“路径和”我本能想到的是遍历每条路径，但那样复杂度太高。后来才发现，把前缀和的思路搬到树上，代码会更简洁：

python复制def pathSum(root, targetSum):
    from collections import defaultdict
    seen = defaultdict(int)
    seen[0] = 1
    
    def dfs(node, cur_sum):
        if not node:
            return 0
        cur_sum += node.val
        res = seen[cur_sum - targetSum]
        seen[cur_sum] += 1
        res += dfs(node.left, cur_sum) + dfs(node.right, cur_sum)
        seen[cur_sum] -= 1
        return res
    
    return dfs(root, 0)

这段代码的关键在于，在树的 DFS 递归过程中，我们维护的是从根节点到当前节点这条路径上的前缀和哈希表。递归进入子树时，哈希表里记录的是祖先链上的前缀和；递归返回时，要记得回溯——也就是把当前节点加进去的前缀和删掉（seen[cur_sum] -= 1），避免影响其他分支的统计。

这个思路的本质是把“从上往下的路径”映射成“两个前缀和之差”，和在一维数组中找子数组和 target 用的完全是同一套逻辑。区别只在作用域：树上每一层递归实际上是在一个受限的“前缀和集合”中查找，而数组是全局的。我最初刷这道题的时候没想通回溯这一步，结果同一棵树上的另一条分支也引入了当前节点的前缀和，答案直接翻倍，调了好久才发现是计数没回滚的问题。

5. 前缀和与差分：一对相辅相成的兄弟

5.1 差分是什么，和前缀和有什么关系

很多人在刷题时会同时看到“前缀和与差分”这两个词，确实，它们是一对非常完美的互补操作。差分数组 d 的定义是：d[i] = nums[i] - nums[i-1]（对 i 从 1 开始），d[0] = nums[0]。它的作用是快速实现“对原数组某个区间整体加上一个数”。

为什么说它和前缀和互补？因为差分数组的前缀和就是原数组。你构造出差分数组，然后对差分数组求一遍前缀和，就还原了 nums。反过来，前缀和数组的差分也还是原数组。它们之间存在一种可逆性。

这个性质在实际刷题中非常有用：当题目需要你“对区间 [l, r] 整体加上 v”然后求最终数组时，你不需要真的对每个元素操作，只需要在差分数组上做 d[l] += v、d[r+1] -= v，最后求一遍前缀和就可以得到新数组。复杂度从 O(区间长度) 降到 O(1) 的区间修改操作，后面再花 O(n) 一次性还原。

5.2 区间加操作的经典二分查找场景

我来给一个非常经典的例子。假设你有 n 个初始为 0 的房间，现在有若干个操作，每个操作告诉你在一段时间范围内每个房间会被使用多少次，问你最终每个房间的使用次数。直接模拟肯定超时，但用差分就可以轻松解决。

python复制def range_add(n, operations):
    diff = [0] * (n + 2)
    for l, r, v in operations:
        diff[l] += v
        diff[r+1] -= v
    res = [0] * n
    cur = 0
    for i in range(n):
        cur += diff[i]
        res[i] = cur
    return res

注意这里 diff 数组长度是 n + 2 而不是 n + 1，原因是为了安全处理 r+1 可能等于 n 的情况，多开一位可以避免越界。这个细节我在写区间操作题的时候踩过坑，r = n-1 时 r+1 = n，如果 diff 只有 n+1 长度，下标 n 恰好还能安全访问，但有些题目里 r 可以取到 n，那就必须 n+2 才稳妥。不要为了省一个元素的空间让代码在边界上翻车。

5.3 二维差分和二维前缀和的组合

二维差分其实是二维前缀和的对称操作，逻辑是一样的：在二维矩阵中，对某个矩形区域整体加上一个数，可以先在差分矩阵上做四个角的操作，最后对差分矩阵求二维前缀和还原原矩阵。

具体来说，如果要在 (r1, c1) 到 (r2, c2) 这个矩形区域每个元素加 v，差分矩阵的操作为：

python复制diff[r1][c1] += v
diff[r1][c2+1] -= v
diff[r2+1][c1] -= v
diff[r2+1][c2+1] += v

然后对 diff 矩阵做二维前缀和，得到的就是加完之后的矩阵。四个角的符号正好对应容斥原理里的加加减减，记起来也不难：左上角加，右上角和左下角减，右下角再加回来。

这种二维差分的技巧在力扣竞赛周赛中经常出现，我印象中有好几道周赛题都直接或间接考察了这个知识点。如果你对二维前缀和已经比较熟悉了，二维差分理解起来会很轻松，它就是倒过来用一次而已。

6. 实操中的常见问题与排查技巧

6.1 边界条件一错再错？前缀和数组长度和下标问题

前缀和题最容易翻车的点就是边界。我自己在做题过程中总结出几个高频边界问题：

第一个是 pre[0] 到底表示什么。如果你选了 pre[0] = 0 的模板，那么 pre[i] 表示前 i 个元素之和，等你查区间 [l, r] 时用的是 pre[r+1] - pre[l]，这个 r+1 很容易在写的时候不小心写成 r。解决办法是写完后自己代入一个简单例子，比如 nums = [1, 2]，查区间 [0, 1]，拿笔算一遍结果是不是 3，是的话就说明边界没写错。

第二个是二维前缀和里 pre[i+1][j+1] 和 matrix[i][j] 的对应关系。很多人在构建 pre 矩阵时会不小心把行列搞混，导致一个 m 行 n 列的矩阵被处理成 n 行 m 列，查询时下标越界或结果错误。我建议你写二维模板时，先固定一个 2x3 的小矩阵（比如 [[1,2,3],[4,5,6]]），手动算一遍 pre，再对照代码检查，这样能迅速把行列关系理清楚。

第三个是哈希表初始值的问题。在 560 题里我们初始化的 count[0] = 1，很多新手会忘记这一步，导致“从开头到当前位置的整个子数组”这种情况没被统计进去。判断方法也很简单：如果用例里刚好有从下标 0 开始的满足条件的子数组，你算出来的答案就会少 1，这就是标志性症状。

6.2 哈希表计数还是存下标？看清题目要求再决定

前缀和配合哈希表时，哈希表里存的到底是什么，很多人会困惑。其实判断标准非常简单：

• 如果题目问“有多少个子数组满足条件”，那哈希表的值应该存“该前缀和出现的次数”，因为每个满足条件的位置都可以单独构成一个答案。
• 如果题目问“是否存在某个子数组满足条件”或“满足条件的最长子数组长度”，那哈希表的值应该存“第一次出现该前缀和的位置”，因为你想要的是最早的位置，以便让子数组最长。

我举个具体的例子，LeetCode 525 题“连续数组”要求找含有相同数量 0 和 1 的最长连续子数组。做法是把 0 当成 -1，把 1 当成 1，那么题目就变成找和为 0 的最长子数组。因为要找最长，哈希表里存的是某个前缀和第一次出现的位置，而不是出现次数。

python复制def findMaxLength(nums):
    seen = {0: -1}
    pre = 0
    ans = 0
    for i, x in enumerate(nums):
        pre += 1 if x == 1 else -1
        if pre in seen:
            ans = max(ans, i - seen[pre])
        else:
            seen[pre] = i
    return ans

这里的关键就是：遇到重复的前缀和，我们不做任何更新，只更新答案；只有遇到新前缀和时才把当前位置存进哈希表。如果你把这里改成“存最近一次出现位置”，答案就会出错，因为那样会把早出现的更优位置覆盖掉。

6.3 数据范围与溢出、取模带来的隐性坑

前缀和数组的值会随着原数组元素和累积而变大，这点在高数据范围题目中要特别留意。虽然 Python 的整数没有溢出问题，但如果你用的是 C++ 或 Java，int 类型很可能在累加过程中溢出，导致答案错误且非常难排查。

我的建议是：在 C++ 中前缀和数组直接用 long long 类型，除非你能确保原数组的和在 int 范围内；Java 中则考虑 long。在 Python 里虽然不会有溢出，但取模运算和负数运算的细节还是要注意。比如 LeetCode 523 题中，对 k 取模时如果 pre 是负数（因为数组里可能有负数），取模结果可能不符合预期，需要额外处理成非负余数。

举个例子，Python 中 -7 % 5 的结果是 3，而在很多其他语言里结果是 -2。如果你在写跨平台代码或与别人讨论时，这个不一致性就会造成困惑。所以在涉及取模的前缀和题目中，我一般会在更新 pre 时手动加 k 再取模，确保余数为非负。具体写法是 pre = (pre + x) % k，然后如果需要非负可以再 pre = (pre + k) % k。

6.4 经典问题速查表

为了让你刷题时能快速定位方向，我整理了一份前缀和相关题型的速查表，都是我反复验证过的经验判断：

这个表不是让你背，而是让你在做题之前先对照题目特征，快速锁定可能的解法方向。方向对了，后面写代码才有意义。

6.5 自己刷题时的三个实用小习惯

最后分享三个我在刷这类题时亲测有效的小习惯。

第一个习惯是“写代码前先写测试用例”。每次遇到前缀和题目，我会先用一个很小的数组（三五个元素）手算一遍预期输出，再跑代码。这能帮你快速暴露边界错误和逻辑疏漏。别小看这个步骤，它能帮你节省大量的调试时间。

第二个习惯是“区分输入数据类型再选算法”。一定要先看题目给的数据范围。如果数组长度 n <= 10^4，O(n²) 的暴力也许可以接受；但如果是 10^5 以上，前缀和 + 哈希表的 O(n) 解法基本就是标准答案。数据范围是最直接、最客观的算法选择依据。

第三个习惯是“刷完后对比官方题解和其他解法”。LeetCode 题解区和讨论区里有很多种写法，我会把自己写的和别人的对比，看有没有人用了更简洁的模板写法或者更巧妙的边界处理。这不是抄答案，而是开阔思路。像二维前缀和多开一行一列这种模板，就是从评论区学来然后固化成自己的风格的。

前缀和系列还有不少变体，比如前缀最值、前缀异或和（在某些位运算题里也很好用），以及前缀和配合单调队列解决滑动窗口类问题等。这个专题如果大家喜欢，我后面可以继续出第二篇，专门聊聊这些升级玩法。刷题这回事，最忌讳的就是眼高手低，模板看着简单，真正动手写一遍才是真的理解了。