前缀和与long long溢出：从一道填坑题理解前缀信息优化

竞赛里的大多数经验，其实都是从几道看起来平平无奇的题里攒出来的。就拿“大姨的最高分数”这个题来说，第一次见到它的人会觉得是水题，扫一遍就完事了；可一旦你把“前缀和”和“记得答案开 ll”这两条提示放在一起，才明白出题人真正想让你练的东西是什么：不是无脑模拟，而是建立“用前缀信息优化重复比较”的模型直觉，以及对整数溢出那一瞬间的敬畏。

这篇文章我就围绕这道题，把前缀和的思考方式、答案为什么要开 long long，以及与之配套的差分、二维前缀和这些“亲戚”一次讲清楚。适合刚学完数组和循环、被算法题虐到迷茫的新手，也适合那些每次看到溢出的红色 WA 都心头一紧的老选手。

1. 题目到底在说什么：从爬山故事到代码模型

1.1 题面还原与核心矛盾

原题的故事背景很有意思：大姨带着娃爬山，一路坑坑洼洼。她的填坑逻辑是——当前所在位置如果比前面所有位置里的“某个位置”低，她就把当前位置填到“前面所有位置都不比它高”的程度，然后带着计数 m 继续往前走。转化出来的题面是：

有 n 个数，第 i 个数是 a_i。还有一个整数 m，初始值为 0。对于每个 a_i：如果它比它前面的所有数中的某个数小，那么就将它和 m 同时加上 1。

这段话最关键的地方在“比它前面的所有数中的某个数小”，不是在和“前一个数”比，也不是在和“前面的所有数”比，而是只要前面存在一个值大于当前值，当前值就要被填一次。

举个例子：a = [5, 3, 4, 1, 6]。位置 1 的值 3，前面有 5 比它大，所以填，m 变 1。位置 2 的值 4，前面有 5 比它大，所以填，m 变 2。位置 3 的值 1，前面有 5、4 都比它大，所以填，m 变 3。位置 4 的值 6，前面没有比 6 大的值，不填。最终 m = 3。

这里的核心矛盾，就是每个位置都要回答同一个问题：“我前面有没有比我大的数？”如果每次都把前面的所有数扫一遍，最坏情况下就不是 O(n)，而是 O(n²)，数据一上来就直接超时。所以必须找到一个办法，把“前面所有数的信息”压缩成一个可以随时比较的状态。

1.2 暴力思路为什么不行：三重循环的惨案

刚学编程的人第一反应通常是：维护一个变量记录当前最大值 mx，遍历数组的时候如果 a[i] < mx 就计数，否则更新 mx。这其实已经是优化版本了。

真正的暴力版本是这样的：两层循环，外层遍历每个位置 i，内层遍历所有 j < i，判断是否存在 a[j] > a[i]。一旦找到就 m++ 并跳出内层。代码写起来很短，但复杂度是严格的 O(n²)。如果 n 是 10^5，循环次数接近 5×10^9 次，在常见的评测机上基本跑不出结果。

还有一种更隐蔽的错误写法：内层遍历时不仅判断是否存在，还统计前面有多少个比它大的数，然后误以为答案是“逆序对数量”。但这道题的填坑规则是“只要前面有大值，当前坑就被填一次”，不管前面有几个大值，对当前这个坑来说都只填一次，计数只加 1。如果不小心把计数写成了累加个数，样例可能碰巧对，换一组数据就会错得离谱。

2. 前缀和式思考：把“前面的最大值”当作状态

2.1 前缀最大值，本质是前缀和的亲兄弟

说到前缀和，很多人的第一反应是区间求和：pre[i] = pre[i-1] + a[i]。但这道题里用到的不是“前缀和”，而是“前缀最大值”。两者本质上是一家人，都属于“前缀信息”——从左往右扫一遍，把前面的信息压缩成一个小规模的量，空间上只需要 O(1) 或 O(n)，时间上只扫一遍。

在填坑这道题里，我们真正需要的“前缀信息”就是：当前位置之前出现过的最大值 mx。因为只要当前值小于这个 mx，就说明前面存在某个数比它大；如果当前值不小于 mx，那前面必然不存在比它大的数。这就是把“和所有前面元素比较”的 O(n) 开销，压缩成了“和最大值比较”的 O(1) 开销。

这种抽象能力是算法题最值钱的地方。不会做题的人看到“前面有没有比我大的数”，第一反应是循环套循环；会做题的人会先问一句：我要比较的到底是一组数，还是一个代表数？当问题只关心“是否存在大于值”时，最大值就是这组数的代表。同理，如果问题关心“是否存在小于值”，代表数就是最小值。

2.2 用一个变量实现 O(n) 扫描

具体实现比我描述的要更短：

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

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

    int n;
    cin >> n;
    vector<long long> a(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }

    long long m = 0;
    long long mx = LLONG_MIN;

    for (int i = 0; i < n; i++) {
        if (a[i] < mx) {
            m++;           // 前面存在更大的值，当前坑被填
        } else {
            mx = a[i];     // 当前值成为了新的前缀最大值
        }
    }

    cout << m << "\n";
    return 0;
}

关键点有三个：第一，mx 必须初始化为一个足够小的值，一般用 LLONG_MIN，而不是 0。因为如果数组里有负数，初始化为 0 会导致第一个负数被判定为“小于前面的最大值”，这明显是错的。第二，判断条件是严格小于，不是小于等于。题面用的是“比它前面的所有数中的某个数小”，“某个数是比当前值大”，所以相等时不填。第三，当 a[i] >= mx 时不要忘记更新 mx，否则后续判断参考的还是旧值。

如果你不喜欢 LLONG_MIN，也可以直接取第一个元素作为初始最大值，然后从下标 1 开始遍历：

cpp复制long long mx = a[0];
for (int i = 1; i < n; i++) {
    if (a[i] < mx) m++;
    else mx = a[i];
}

这两种写法都行，第二种更贴近“第一个元素天然是当前前缀最大值”的直觉，但要注意数组空指针和 n=0 的边界。

2.3 手算验证一组数据

我建议你在写代码之前，先手动过一遍数据，这比直接敲代码更容易发现理解偏差。以 a = [2, 2, 1, 3] 为例：

• 位置 0，值 2，此时前面没有元素，mx = 2，不计数。
• 位置 1，值 2，前面最大值是 2，2 < 2 不成立，不计数。注意这里两个数相等，不构成“填坑”。
• 位置 2，值 1，前面最大值是 2，1 < 2 成立，计数 m = 1。
• 位置 3，值 3，前面最大值是 2，3 < 2 不成立，更新 mx = 3。
• 最终 m = 1。

再验证一个全部递减的数据 [6, 5, 4, 3, 2, 1]。每个数前面都有一个更大的数，所以每个位置都要填，m = 5。如果题目给你一个很大的 n，比如 10^6，那么 m 最大也只是 10^6-1，int 完全装得下。那为什么还要“记得答案开 ll”？这就是下一节的重点。

3. 为什么“答案记得开 ll”：一次溢出事故给我的教训

3.1 int 到底能存多大：2.147 亿的边界故事

int 在绝大多数评测环境中是 32 位有符号整数，最大值是 2147483647，也就是大约 2.147×10^9。如果继续往上加，就会发生“回绕”——从正数变成负数，这在很多题目里会直接产生错误答案。

long long（简称 ll）是 64 位有符号整数，最大值大约是 9.22×10^18。这个范围能覆盖绝大多数题目。在很多题解里，你会看到作者习惯于把所有跟累加、计数、数组下标计算相关的变量都声明为 long long，甚至有人干脆在代码开头写死：

cpp复制#define int long long

这种做法的确省心，但不建议所有题目都这么干。因为 long long 占用的内存是 int 的两倍，如果题目要求开一个 10^7 级别的数组，你用 int 是 40MB，用 long long 就是 80MB，评测机的内存限制可能是 64MB，直接内存超限。

3.2 到底什么会爆，什么不会爆

拿这道题单独看，m 最大是 n-1，如果 n ≤ 10^6，int 完全足够。那为什么出题人和给你提示的人反复强调“记得开 ll”？

第一种可能是数据范围比你想象的大：虽然数组不能无限开，但如果题目允许 n 达到 10^9 级别的“假数组”，或者通过生成函数循环调用，计数就可能远超 int 上限。

第二种可能是多组测试数据：假设有 T 组测试，每组答案都要累加到一个总答案变量里。T 最大 10^5，每组答案平均 10^5，总答案就能到 10^10，这已经超过 int 的边界了。

第三种可能，也是我最想强调的：做算法竞赛时，你永远猜不到隐藏测试点里藏着什么。我记得有一次做一道看似简单的区间求和题，思路完全正确，但答案变量用了 int。数据里有几组是大区间，区间内部的和超过了 2.1×10^9，于是同样的代码在本地小数据上全对，一交上去就 WA。从那以后，凡是和“求和”“计数”“累加”相关的变量，我第一反应就是 long long，除非题目明确告诉你答案范围很小。这里也刚好回应一下你搜到的其它关键词里出现的“ll”——在别的语境里，它可能是链接器选项 -ll，也可能是 STM32 的 LL 库，但在这道题里，它只有一个意思：long long。

3.3 评测里的真实场景：多组数据累加、大 n、求和相关

如果你正在刷题库，会发现很多题目会把“你只需要输出最后答案”改成“每次操作的贡献累加”，或者把“单次询问”改成“多次询问求和”。这种变形一出现，答案数量级就立刻上去了。

举个例子，如果题目不是叫你统计“填了多少个坑”，而是叫你统计“每填一个坑，当前坑被填到的高度差的总和”。每次填坑时，新高度是前面的最大高度 mx，当前值是 a[i]，贡献是 mx - a[i]。假设 mx 是 10^9，n 也是 10^6，所有坑都填一遍，总贡献最坏就是 (10^9)×(10^6) = 10^15。这早就超过 int 的范围了，必须用 long long。这种“求和 + 大范围”的组合，正是“答案开 ll”这个提醒真正想防的事。

顺便再补充一个细节：在 C++ 里，如果你把 a[i] 定义为 int，但在计算 sum += a[i] 时，sum 是 long long，那么加法会先把 a[i] 提升为 long long 再计算，这是安全的。但如果你写 long long sum = 0; sum += a[i] * a[j];，而 a[i] 和 a[j] 都是 int，那么 a[i] * a[j] 会先以 int 相乘，再转成 long long。当两个 10^9 级别的 int 相乘时，相乘结果在 int 域内已经溢出，之后再转成 long long 也救不回来。这是溢出问题里最容易踩的暗坑，一定要格外留意。

4. 前缀和与差分的家族扩展：从这题走向一类题型

4.1 一维前缀和

前缀和的核心公式是：

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

查询区间 [l, r] 的和就是：

cpp复制if (l == 0) ans = pre[r];
else ans = pre[r] - pre[l-1];

这个操作把单次区间求和的复杂度从 O(n) 降到 O(1)，代价是一次 O(n) 的预处理。如果你要处理 Q 次区间求和，暴力是 O(nQ)，前缀和是 O(n + Q)。在 n 和 Q 都是 10^5 时，暴力和优化的差距是数量级的。

4.2 差分：前缀和的逆运算

差分数组的定义是：

cpp复制diff[i] = a[i] - a[i-1];

它和前缀和是一对互逆操作：对差分数组求前缀和，能得到原数组；对原数组求差分，能得到变化量。

差分的经典应用是“区间加同一个值”。比如你要在 [l, r] 之间的所有元素都加上 k，朴素做法是遍历区间逐个加，复杂度 O(n)。用差分只需要两步：

cpp复制diff[l] += k;
if (r + 1 < n) diff[r + 1] -= k;

最后再对 diff 求一遍前缀和，就能得到所有区间加操作完成后的数组。这在处理大量区间修改时极其高效。做这类题时也别忘了，操作次数乘上单次值可能很大，差分的中间变量和最终答案同样要开 long long。

4.3 二维前缀和

二维前缀和是另一个常见变形。比如给一个 m×n 的矩阵，求任意子矩阵的和。预处理公式是容斥原理：

cpp复制pre[i][j] = a[i][j] + pre[i-1][j] + pre[i][j-1] - pre[i-1][j-1];

查询左上角 (x1, y1)、右下角 (x2, y2) 的子矩阵和：

cpp复制ans = pre[x2][y2] - pre[x1-1][y2] - pre[x2][y1-1] + pre[x1-1][y1-1];

二维前缀和最大的坑也在溢出：矩阵每个格子最大值如果是 10^9，而 pre 数组里存的是从左上角到当前位置的所有格子之和，最大值是 m×n×10^9。如果 m×n 是 10^6，这个值就达到 10^15，必须用 long long。如果你在代码里用了 int 数组，预处理时可能已经溢出，后面查出来的结果全是错的。

4.4 这类题的通用套路

从“填坑”这道题，加上前缀和、差分、二维前缀和，其实能总结出一套通用套路：

• 先问自己：这个问题是不是“多个位置反复查询/比较某个区间或前缀的信息”？
• 如果是，尝试用一维前缀和、前缀最大值、前缀最小值、前缀异或和等“前缀信息”来预处理。
• 如果问题是“多次区间修改、最后求数组”，优先考虑差分。
• 如果是矩阵区域的查询或修改，考虑二维前缀和、二维差分。
• 无论哪一步，只要涉及“累加”和“计数”，在不确定范围的时候，默认用 long long 存结果。

这套套路在刷题时非常实用。你不需要背模板，只需要在看到题目时识别出“前缀状态”的模型，然后套上对应的数据结构。

5. 常见问题与避坑清单

5.1 5个最容易踩的坑

我在给初学者答疑时，发现这道题相关的错误集中在这几个地方：

第一个坑，前缀最大值比较条件写错。有人把 if (a[i] < mx) 写成了 if (a[i] <= mx)，这样相等的情况也被计数。题面要求“比某个数小”，相等不算填坑，必须严格小于。

第二个坑，忘记更新最大值。这是个低频但致命的错误，因为你前几个数据可能碰巧都对，到了某个位置后 mx 还是几轮之前的值，计数会变成“和过期最大值比较”，结果完全错乱。

第三个坑，输入输出效率问题。如果使用 cin 而没有关闭同步，在处理 10^6 级数据时可能会超时。我习惯在程序开头写：

cpp复制ios::sync_with_stdio(false);
cin.tie(nullptr);

或者直接改用 scanf / printf。这不是这道题独有的问题，但很多新手在 n 大了以后才第一次体会到这里痛。

第四个坑，用 int 存数组下标。当 n 超过 2×10^9 时，int 下标本身就会溢出。但实际情况中你很少遇到这么大的 n，所以这个坑通常隐藏在“二维数组的一维展开计算”里，比如把一个很大的二维矩阵拍平成一维时，下标计算公式中间结果可能超过 int。

第五个坑，本地测试全过、评测却 WA，却很可能是溢出。前面已经提过 int 相乘的问题，建议所有涉及乘法、累加、前缀和的中间变量一律检查范围，必要时输出中间量对比数据范围。

5.2 ll 在不同语境下的奇闻

如果你是因为看到了“multipath -ll 输入后无信息”或者“stm32g031 usart dma ll库”这些关键词才点进来的，那你会发现在不同技术领域，“ll”完全是不同的东西：

• 在链接器参数里，-ll 可能是链接某个名为 l 的库。
• 在嵌入式开发里，LL 是 Low Layer 的缩写，比如 STM32 的 LL 库，提供比 HAL 更接近底层的操作接口。
• 在算法竞赛和 C++ 代码里，ll 几乎已经是 long long 的代名词，很多题解直接写 typedef long long ll; 来减少代码量。

看到同一个缩写出现在截然不同的上下文，恰恰说明技术学习不能只背单词，要理解上下文。回到这道题，你看到“记得答案开 ll”，就应该立刻反应出“输出变量要用 long long 类型”，而不是想什么链接库或嵌入式驱动。

5.3 经验技巧：如何快速判断要不要开 ll

我个人的习惯是，拿到一道题先看数据范围，然后计算最坏情况下答案的边界：

• 如果 n 和 a_i 的最大值都 ≤ 10^5，那么单次累加最多 10^10，已经超过 int，用 long long。
• 如果不确定，直接在定义时用 long long，只有当你明确知道答案不超过 2.1×10^9 时才用 int。
• 如果题目内存限制紧张，而答案确实很小，再用 int，但中间可能出现乘法或临时量，例如 a[i] * a[j]，需要单独把其中一个转成 long long 后再乘。

写代码时还有一个习惯值得培养：不要等到 WA 了再回去改类型，而是在设计算法时就把类型规划好。把“答案、累加器、前缀和数组、差分数组”都默认当作 long long，然后用 1LL * 这样的方式来强制乘法先转 long long：

cpp复制long long ans = 1LL * a[i] * a[j];

这种写法能在不牺牲太多内存的前提下，把大部分溢出风险挡在门外。

我个人在刷题里最深刻的体会就是，WA 不可怕，可怕的是思路完全正确，却因为一个 int 溢出浪费了两个小时。从那以后我写和前缀、求和、计数相关的题目，第一行 long long m = 0; 几乎成了肌肉记忆。这道“大姨的最高分数”最值得你带走的，不是那段 O(n) 扫描的代码，而是这种“看到计数就想到上限，看到累加就想到溢出”的意识。算法模板会过时，这种安全意识会让你一直少踩坑。