优先队列与多路归并：解最小函数值问题的堆式思维

关于“优先级队列：最小函数值”这题，网上能找到的原型很经典，但不少初学堆的人第一次看完题解仍然会懵。这篇我不打算只是把代码贴出来，而是把这条题从“为什么要用优先队列”到“代码里那些反直觉的细节”完整拆一遍，尽量让你看完之后能自己推导出答案，而不是背模板。

我先把题面简化成我理解的样子：有 n 个二次函数 f_i(x)=a_i x^2 + b_i x + c_i，其中 a_i、b_i、c_i 都是正整数或非负整数，x 只能取正整数。现在要求把 x=1,2,3,... 代进去得到的函数值全部混在一起，按从小到大输出前 m 个。函数很多，n 和 m 都可能到 1e4 甚至更大，所以不能把每个函数的前 m 项全部暴力算出来再排序。标题里的“优先级队列”就是这里的破局关键，而“最小函数值”这几个字已经暗示了一个很重要的直觉：每个函数本身已经是一串有序数值，我们要做的是把多串有序序列合并成一条全局有序序列。

我写这篇的时候默认你至少知道堆这个数据结构，知道最小堆能够在 O(log n) 时间内拿到并删除最小值、再以同样代价插入新元素。但就算你对堆不熟也没关系，后面我会把每一步动作落到具体的堆操作上，你照着推一遍就能理解。

1. 先拆掉包装：这题其实是在合并 n 条已经有序的“链”

很多看起来复杂的题目，翻译成数据结构语言之后都会变得非常简单，这道题就是典型。

1.1 为什么每个函数天然是一条递增链

原题里通常保证 a_i, b_i, c_i 都是非负的，而且 a_i 不为 0。二次函数 f_i(x)=a_i x^2+b_i x+c_i 在 x>0 时并不一定对所有 a_i、b_i 都递增，比如 a_i=0, b_i=-10, 那 f_i(x)=-10x+c_i 是递减的。所以出题人为了降低模型难度，一般会把系数限定为正数，甚至让递增值强制为正。其实你仔细想一下题目的含义：如果某些函数会递减，那么“把所有函数值混在一起取前 m 小”会变得更复杂，因为你还得考虑一个函数后面的值可能比它前面的值还小，整个数据流的顺序就被打破了。

因此，在这类题里，一个默认条件是：每个函数在正整数定义域上基本单调不减，至少在 x 从 1 开始逐步增加时，f_i(x) 是不会回退的。

有了这个前提，函数 i 就可以写成一条链：

f_i(1) → f_i(2) → f_i(3) → f_i(4) → ...

链上的元素从前往后是递增的。现在题目里有 n 个这样的函数，于是就有 n 条有序链。我们要做的，是把这 n 条有序链合并成一条全局有序的链，并且只需要取前 m 个元素。

1.2 从“合并两个有序数组”到“合并 n 条链”

如果你做过“合并两个有序数组”或者“合并 K 个有序链表”，那这道题的模型你就很熟了。

合并两条有序链表时，你会维护两个指针。每次比较两个指针所指的元素，谁小就输出谁并让那个指针往后走一步。合并 K 条链表时，如果从头到尾顺序比较 K 个链表的当前元素，那每一轮都要花 O(K)；而堆的作用就是把“从一个集合中选出最小值”这个动作从 O(K) 降到 O(log K)。

n 个函数也一样。每个函数都有一个“当前指针”，一开始指向 x=1。我们想知道 n 个当前值里哪个最小，这就是一次取最小操作。取完最小之后，对应函数的指针要往后移到 x=2，把新值放回候选集合里。这个过程重复 m 次。

所以题目名字虽然叫“最小函数值”，本质却是“多路归并”。看到这里你应该已经明白，为什么这类题目会被归到优先队列专项练习里。

2. 不直接讲堆做法，先看两个大多数人都会踩的复杂度陷阱

我在不同地方讲这道题的时候，总会遇到有人说“直接全部算出来，排个序不就行了吗”。这句话在样例规模下确实没有错，因为样例可能只有两三个函数、输出四五项，怎么算都行。但竞赛题的规模一上来，暴力就会死得很难看。

2.1 暴力方案一：把 n 个函数的前 m 个值全部生成，然后全局排序

如果 n 和 m 都是 1e4，那么要生成的函数值个数是 n × m = 1e8。这已经是一个非常夸张的数字了。就算每个数只占 8 字节，光存储就需要 800MB，这还没算排序过程额外消耗的内存和比较开销。再考虑对这些数排序，复杂度至少是 O(nm log(nm))，哪怕常数极小也完全不可能通过。

这个方案的致命点在于：它把“此刻根本不需要生成的值”也提前生成出来了。我们只需要前 m 小，可是很多函数在 x 比较大的时候可能根本不会进入前 m 的候选范围，把这些值算出来纯属浪费。

2.2 暴力方案二：每轮扫一遍所有函数，找当前最小值

还有人会想：那我不全部生成，我给每个函数只保留一个当前“指针”，每一轮扫描一遍所有 n 个函数的当前值，找出最小的，然后让对应函数的指针前进一步。这样时间复杂度是 O(n × m)，空间复杂度是 O(n)，看起来比全局排序合理很多。

如果 n 和 m 都只有 5000，这个方案确实能扛过去，因为 5000×5000=2.5e7，扫描的常数又小，有机会擦边过。但 n 和 m 变成 1e4 就是 1e8 次扫描，虽然 1e8 在 C++ 里理论上一秒左右能跑完，但如果数据再多组、或者 n 和 m 到 1e5，这种方案就彻底没戏了。

更关键的是，线性扫描的行为本质上是一种“没有堆结构”的朴素动态维护。你每次都重新找所有 n 个数的最小值，但上一次扫描得到的信息完全没有被利用。堆恰好就是为了解决这类“动态集合里反复取最小”的问题而存在的。

2.3 直觉对比：把反复求最小变成 O(n) → O(log n)

来算一笔复杂度账。堆做法里，初始时把 n 个函数的第一项都放进最小堆，需要 O(n)。之后每一轮输出要执行一次取最小和一次插入，也就是两次 O(log n) 操作。总共 m 轮，整体复杂度就是 O((n+m)log n)。

当 n 和 m 都接近 1e5 时，n×m 是 1e10 级别，而 (n+m)log n 只是 2e5 × 17 左右，大约几百万次操作。这已经不是一个量级的差距。你可能会想：那也不只是“取最小”，每次取完最小还得知道它来自哪个函数，并且要能算出这个函数的下一个值。堆节点里保存的信息就派上用场了。

3. 核心循环只有三个动作：入堆、弹出、补位

讲理论不如直接讲流程。这一章我会一步步拆解最小函数值题的标准堆解法，并且用一个具体小规模例子做一次手算模拟。

3.1 算法流程：一个动作一个动作看

先定义清楚一个函数当前到了哪个自变量。我们用 curX[i] 表示函数 i 下一次要被考虑的是第几个 x，初始时 curX[i] = 1。

算法步骤：

1. 初始化一个空的最小堆。
2. 遍历 i 从 1 到 n，计算 val = f_i(1)，把 (val, i) 放入堆中。这里的 i 用来记录这个最小值是从哪个函数来的。
3. 重复以下过程 m 次：
   • 从堆顶弹出 (val, i)，这个 val 就是当前所有未输出函数值中的最小值。
   • 输出 val。
   • 把函数 i 的当前自变量指针加 1，即 curX[i] += 1。
   • 计算新值 newVal = f_i(curX[i])，然后把 (newVal, i) 重新放进堆里。

这个流程可能比你想象的短。它没有复杂的分类讨论，也没有需要特殊处理的边界，唯一值得注意的是堆节点里除了函数值，还必须记录来源函数的编号，否则弹出最小值后你根本不知道下一步该让哪个函数前进。

如果不记录来源，相当于你只取出了“值”，却丢失了“这个值是从哪条链上来的”这一关键信息。这也是很多人照着题解写却写错的原因之一。

3.2 手算模拟：三个函数推一遍

为了让你感受流程，我们取三组比较简单的函数：

• f1(x) = x^2 + x + 1
• f2(x) = x^2 + 2x
• f3(x) = 2x^2 + x

先把 x=1 代入：

f1(1)=3，f2(1)=3，f3(1)=3

初始堆里就会有三个值相同的节点。由于堆对相同值没有特殊规定，任意顺序输出都行。假设我们先弹出 f1 的值 3。

输出 3 之后，把 f1 的 x 从 1 推到 2，计算 f1(2)=7，把 7 放回堆里。此时堆里有：

• f1 的下一个候选：7
• f2 的当前候选：3
• f3 的当前候选：3

最小值仍然是 3。假设接下来弹出 f2 的 3，然后让 f2 前进到 x=2，f2(2)=8。堆里变成 7、8、3，最小值是 3，来自 f3。

继续弹出 f3 的 3，让 f3 前进到 x=2，f3(2)=10。现在堆里有 7、8、10，最小值是 7，来自 f1。

第七轮输出之后 f1 前进到 x=3，f1(3)=13，此时堆里有 8、10、13，所以第五个输出应该是 8……整个过程非常机械。想一下，这个流程和“合并三条有序链表”是不是一模一样的？当初合并三条升序链表的时候，也是把三条链表的当前表头放入堆里，每次弹出一个最小值，然后让对应那根链的表头后移，再重新放回堆。

3.3 为什么堆大小始终是 n 左右

注意观察上面的模拟，堆里最多同时存在的节点不会超过 n 个。初始 n 个，每次弹出一个，又塞回一个，数量只会保持在 n 或 n 附近。空间复杂度是 O(n) 级别。

有些实现为了省事，弹出最小值后不是重新计算函数值，而是把一个结构体整体弹出，修改它的 x 后再塞回去。这种写法同样保持堆大小不变。还有的实现会用数组额外记录每个函数当前已经推进到的 x，这样堆节点只需要存 val 和函数编号，两种风格各有取舍。我更喜欢把 x 直接存在节点里，出堆后更新 x 再重新入堆，让节点自包含，不容易因为多个函数共用一个计数数组而出错。

3.4 一个容易忽略的“大前提”：被弹出去的值，必须保证以后不会再被其他函数产生

这里要特别澄清一个细节：函数值不一定是全局唯一的。不同函数之间可能算出相同的值，同一个函数也可能在 x 不同的情况下得到相同的值。正因如此，我们弹出某个节点的值时，不能假设“这个值只出现这一次”。堆里的节点是“候选位置”，不是“值的一次性标签”。如果你把值相同的节点同时留在堆里，并且在弹出其中一个后把同一个函数的下一个值重新入堆，那么后续仍然可能会弹出另一个函数相同值的节点，这完全符合题意，因为题目要求的是“最小的 m 个函数值”，而不是“m 个不同函数值”。

4. 正确性并非表面看起来那么简单：为什么推进一格就够了

不少读者可能觉得堆解法“看起来对”，但说不出为什么对。如果只停留在“每次取最小值，然后更新它”这一步，你就很难真正向别人解释这个算法，出题者如果追问你的证明，你也说不清楚。

我建议你把整个算法理解成一个循环不变量：每一轮都保证，堆里存放的是每个函数尚未输出的最小值候选。

4.1 循环不变量：一个函数只保留一个“代表”就够了

设当前某个函数 i 目前为止已经输出了 x=1、2、...、k-1 这些项，那么函数 i 还没有输出的最小一项就是 f_i(k)。由于函数值随 x 递增，这个 f_i(k) 是函数 i 产生的所有尚未输出值中的最小值。我们在堆里为函数 i 保存的，正是这个“代表”。

现在所有函数都各自派出了一个代表，堆顶就是所有代表中的最小值。那么全局所有尚未输出的函数值里，有没有可能比堆顶还小的值？答案是没有。因为任何一个尚未输出的值都归属于某个函数，而该函数代表的值不大于这个尚未输出的值。既然代表值都不小于堆顶，那个尚未输出的值就必然更大或相等。

所以，每轮输出堆顶是绝对正确的。

4.2 弹出后为什么让 x 加 1，而不是重新比较这个函数所有可能的 x

有人会想：函数 i 弹出的是 f_i(k)，我为什么只让 x 从 k 走到 k+1？万一 f_i(k+2) 比别的函数最小值更小呢？

答案是：f_i(k) 都已经被选中输出，由于函数在这类题目中单调递增，f_i(k+1) 一定小于等于 f_i(k+2)，所以当 f_i(k) 已经输出之后，f_i(k+1) 是这个函数当前最小的未输出值。至于 f_i(k+2) 排在 f_i(k+1) 后面，只有等到 f_i(k+1) 也被输出后才有可能进入“该函数代表”的位置。这个逻辑和你在合并有序链表时只有在当前指针位置输出后才把指针向后移动一位是一样的，因为链表已经有序，你不可能跳过 f_i(k+1) 直接取 f_i(k+2)。

4.3 相等的函数值会影响正确性吗

不会。堆排序算法处理相等值的时候，弹出哪一个都行。因为它们的值相同，输出的先后顺序不影响最终结果。你可能担心的是“相等值会不会导致两个函数选出的代表不是实际上的最小”，比如某两个函数在 x 不同的位置都算出了同一个值，但堆里只保留了其中一个函数的值。这种担心是多余的，因为堆里每个函数都有代表，如果某个函数的某个未输出值小于堆顶，那这个函数当前的代表一定小于等于那个值，也就一定会体现为比堆顶更小或相等。

核心在于：我们不是基于数值本身去散列表判重，而是基于“链上的顺序推进”。只要链是单调的，代表法就是完备的。

5. 代码落地的关键写法：最小堆不是天然存在的

原理想通之后，实现才是新手真正翻车的地方。不同语言的优先队列风格差异很大，这一章我会给出 C++ 和 Python 两个版本，并把最容易写错的地方单独挑出来说。

5.1 用 C++ 写最小堆，比较器方向要反着理解

C++ 的 std::priority_queue 默认是大顶堆，也就是 top() 返回的是“按比较器认为最大”的元素。如果你想让它变成最小堆，最直观的方式是在比较器里把优先级反过来定义。

我建议直接存一个结构体节点：

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

vector<long long> A, B, C;

long long calc(long long a, long long b, long long c, long long x) {
    return a * x * x + b * x + c;
}

struct Node {
    long long val;
    int idx;
    int x;
};

struct Cmp {
    bool operator()(const Node& u, const Node& v) const {
        // 注意：priority_queue 是“最大堆”
        // 所以这里如果希望 val 最小的在堆顶，要返回 u.val > v.val
        return u.val > v.val;
    }
};

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

    int n, m;
    cin >> n >> m;

    A.resize(n);
    B.resize(n);
    C.resize(n);

    for (int i = 0; i < n; i++) {
        cin >> A[i] >> B[i] >> C[i];
    }

    priority_queue<Node, vector<Node>, Cmp> pq;

    for (int i = 0; i < n; i++) {
        pq.push({calc(A[i], B[i], C[i], 1), i, 1});
    }

    vector<long long> ans;

    while ((int)ans.size() < m) {
        Node cur = pq.top();
        pq.pop();

        ans.push_back(cur.val);

        cur.x++;
        cur.val = calc(A[cur.idx], B[cur.idx], C[cur.idx], cur.x);
        pq.push(cur);
    }

    for (int i = 0; i < m; i++) {
        if (i) cout << ' ';
        cout << ans[i];
    }
    cout << '\n';

    return 0;
}

这里最坑的就是 Cmp::operator() 里返回 u.val > v.val 反而会让小值在堆顶。不理解的话不要硬背，我提供一个记忆方法：priority_queue 定义的是“谁应该排在最后面”的比较关系。 当比较器认为 u 比 v 优先级低时，u 就会沉底。用 u.val > v.val 表示 val 更大的 u 优先级更低，因此比较大的值会沉到底部，最小的自然就在顶上。

除了比较器，还有两个极容易写错的点：一是忘记在弹出后更新 cur.x 就直接重新入堆，那样等于把同一个值无限输出；二是在计算 a*x*x 时没有开 long long，导致中间结果溢出。x 在反复推进之后可能变得相当大，函数值很容易超过 int 范围，所以 val 的类型必须用 long long。

5.2 Python 版：heapq 本身就是最小堆，写法会更直接

Python 的 heapq 天然就是最小堆，不用像 C++ 那样调比较器方向，这是它的优势。但堆元素如果直接存元组，要注意元组比较的规则。

python复制import heapq

n, m = map(int, input().split())
A = []
B = []
C = []

for _ in range(n):
    a, b, c = map(int, input().split())
    A.append(a)
    B.append(b)
    C.append(c)

def f(i, x):
    return A[i] * x * x + B[i] * x + C[i]

heap = []

# 每个函数都从 x = 1 开始
for i in range(n):
    heapq.heappush(heap, (f(i, 1), i, 1))

res = []

while len(res) < m:
    val, i, x = heapq.heappop(heap)
    res.append(str(val))

    # 这个函数的下一个 x
    x += 1
    heapq.heappush(heap, (f(i, x), i, x))

print(' '.join(res))

如果你直接在堆节点里存 (val, i, x)，当 val 相同的时候，Python 会继续比较 i，如果 i 也相同再比较 x。这种比较总是合法的，不会出错。但要注意，如果你只存 (val, i) 而不记录 x，那么当某个函数的相同值被弹出很多次时，你无法知道它现在推进到了 x 的哪一位，所以 x 要么写进元组，要么单独开一个数组维护而序列没有元素，否则更新就无从谈起。

5.3 三个最常见的“不是算法错，是代码错”的情况

第一个情况是把堆初始化成了空堆，却在循环里还没有入堆就弹出，这发生在你忘了把 n 个函数的第一项全部预处理进去时。通常解决方法是初始化阶段先单独循环一次。如果你在读取系数的时候就 push，那么必须等所有系数读完再做，否则部分函数可能数据缺失。

第二个情况是同一组测试样例存在多组数据，但堆没有清空，导致上一轮残留节点影响下一轮输出。多组样例的数据量加起来很大时，强烈建议把堆的声明放在每组数据内部，或者每次重新 new 一个新的 priority_queue。

第三个情况是输出格式。题目如果要求“每行输出前 m 个函数值，空格分隔”，那么行末多一个空格通常会被判为 Presentation Error。我上面的代码用 vector 暂存 ans，最后统一输出，就是为了避免每轮输出时去判断“是不是第一个输出”造成额外麻烦。

6. 把这道题的姿势迁移到其他“最小若干值”问题

如果只把这道题当一个孤立模板题，那收获会打折。事实上，“最小值函数值”的堆解法是很多算法问题的核心骨架，只不过题目换了一层皮。

6.1 超级丑数和多路归并其实都在做同一件事

比如生成“超级丑数”：给定一个质数列表 primes=[2,3,5]，从小到大生成所有只含这些质因子的正整数。你可以把它看成若干个有序序列的合并吗？可以。第一路由所有 2 的倍数构成但需要维护……这里直接展开会比较复杂，但核心思想是一致的：每个候选序列都必须是有序的，同时需要一个优先级队列来合并这些序列，每次取出当前最小值并生成该序列的下一项。

另一个更明显的例子是“合并 K 个升序链表”。LeetCode 23 这道题的解法之一就是把 K 个链表的头节点放进最小堆，每次弹出最小的节点，然后把该链表的下一个节点再放进堆。这个模式跟最小函数值题几乎逐行对应。链表题里节点的 next 已经给好了，而函数值题里的 next 要通过自变量 x 加 1 用函数表达式算出来。所以你也可以把这道题理解成：每个函数是一条隐式链表，next 指针不是显式提供的，而是通过“x 加 1 后再代一次函数”得到的。

6.2 如果题目只问“第 m 小的函数值”，堆未必是最优解

最小函数值题在很多版本里并不是让你输出前 m 个函数值，而是直接问“第 m 小的函数值是多少”。这种问法下，另一种常见又高效的思路是二分答案。

因为每个函数都单调递增，所以给定一个候选值 mid，我们可以对每个函数二分查找满足 f_i(x) ≤ mid 的最大 x，然后累加所有函数的 x。累加结果 >= m，说明 mid 偏大；否则 mid 偏小。这样做的时间复杂度是 O(n log m log range)，而且不需要维护堆。对于只需要“第 m 小”而不用输出前 m 个具体值的题目，这种二分做法通常写起来更清晰，尤其是当 m 很大时，它避免了 m 次堆弹出。

但注意，如果题目要求把前 m 个值全部输出，二分法仍然能够通过一次边界计算找到第 m 小的值，然后遍历所有函数收集所有小于等于该值的函数值。不过当函数值分布稀疏、前 m 个值之间跨度很大时，你需要小心处理等于边界值的一圈，避免多收集或少收集。相比直接弹 m 次堆，并不一定更好。这里我建议你就根据题目要求做选择：要求输出所有前 m 个值，堆算法简单直接；只问第 m 小值，二分计数法通常更快。

6.3 进阶思考：不是二次函数，而是一堆有序流，能不能用同样的套路

如果题目把二次函数换成一些单调递增的递推数列，比如给定某个数列的前一项让你通过递推公式计算后一项，只要每一项已知且单调不减，上面的堆算法依然成立。你会发现，堆算法根本不关心函数的具体表达式，只关心三件事：

• 当前整体最小值是谁；
• 这个最小值来自哪一个流；
• 取出最小值后，该流的下一个值是什么，怎么计算。

这三个问题解决了，任何“多路有序流合并”的问题都能用同一套逻辑。也因此我才反复强调，最小函数值题不应该被当成数学函数题去解，它本质上是数据结构里的多路归并题。优先队列在这里扮演的角色不是“排序器”，而是“动态最小值的维护器”。

一个可以带去实战的小结：先定好每个节点的更新规则，再写代码

我见过不少同学写下优先级队列模板时很流畅，但一遇到“最小值函数值”就会卡住，主要原因不是不会写堆，而是没有提前定义清楚堆里每个节点的含义。他们可能会在堆里只存一个数字，然后发现弹出数字后无法回溯到函数来源，于是卡死在更新阶段。

所以，最后分享一个我自己的做题顺序：拿到题目后先不要急着写代码，先问自己两个问题。第一，堆里的每个节点代表什么？第二，从堆里弹出一个节点后，下一个要放入堆的节点是什么？只要这两个问题的答案清晰了，代码其实只是机械地把节点塞进结构体里。对于最小函数值这道题，第一个问题的答案是“每个函数当前未输出的最小候选值”，第二个问题的答案是“该函数自变量加 1 后再代入原函数得到的值”。想清楚这两点，即使你没有背过这道题的模板，也能在考场上现场把它推出来。