【三年面试五年模拟】2026-09-06 拼多多 AI Agent研发岗秋招笔试4道算法题完整题解

写在前面

欢迎大家关注Rocky的知乎：Rocky Ding

《三年面试五年模拟》AIGC/LLM/AI Agent算法工程师/开发工程师求职面试秘籍独家资源：【三年面试五年模拟】WeThinkIn/AIGC-Interview-Book，欢迎大家Star～

Rocky最新撰写的10万字AI Agent（AI智能体）深入浅出全维度解析文章： 深入浅出完整解析AI Agent（AI智能体）的核心基础知识

AIGC/LLM/AI Agent算法岗/开发岗求职面试内推学习社群 （涵盖AIGC、LLM大模型、AI Agent、传统深度学习、自动驾驶、机器学习、计算机视觉、自然语言处理、强化学习、大数据挖掘、具身智能、元宇宙、AGI等AI行业最新面试干货经验与核心知识）欢迎大家加入：https://t.zsxq.com/33pJ0

大家好，我是Rocky。

核心导读

这套笔试只有四道题，但覆盖了算法工程里四种非常典型的建模能力：单调资源下的贪心扫描、模意义下的计数、带历史约束的最短路，以及二分图上的全局匹配。题目表面分别讲钥匙、整除、魔法边和赛马，底层却在反复考察同一件事：能否从业务叙述中识别真正影响未来决策的状态，并用证明而不是直觉删掉无关信息。

四道题对应的核心抽象如下：

题目	表面问题	核心模型	关键不变量	复杂度
第一题	传送带开箱与反转	单调资源 + 双向完整扫描	开箱只增加钥匙，立即打开不劣	O ( n 2 ) O(n^2) O(n2)
第二题	两数之和是 k k k 的倍数	余数桶计数	只需保留 a i m o d k a_i \bmod k aimodk	O ( n ) O(n) O(n)
第三题	限次且不可连续的魔法边	状态扩展 + Dijkstra	位置、已用次数、上一边类型共同决定未来	O ( ( m + p ) k log ⁡ ( n k ) ) O((m+p)k\log(nk)) O((m+p)klog(nk))
第四题	左右赛马最大得分	二分图最大权完美匹配	+ 1 / − 1 +1/-1 +1/−1 下最大化得分等价于最大化胜场	O ( N 3 ) O(N^3) O(N3)

Rocky 认为，这类题真正区分候选人的地方，不是能否背出 Dijkstra、匈牙利算法或余数桶，而是能否回答三个问题：为什么这个状态足够？为什么这一步选择不会破坏最优解？题面改变哪一个条件后，当前算法会立刻失效？下面的题解会围绕这三条线展开。

笔试题与题解

第一题：

机器人初始有 0 把钥匙，传送带上有 n 个箱子排成一列，a $i$ 表示打开第 i 个箱子需要的钥匙数。

每打开一个箱子获得 1 把钥匙。

机器人只能取自己面前的传送带传来的箱子，但可以随时反转传送带方向。

问：能否打开全部箱子？如果可以，最少反转几次方向？

回答：

建模

结合题目给出的"从端到端是最优的，直接一遍遍正反扫"提示，这里的过程应理解为：传送带沿当前方向运动时，箱子会依次经过机器人；当前箱子打不开，就保留在传送带上并继续等待以后某一轮，但它不会阻挡本轮后面的箱子经过。机器人到达一端后可以反转传送带，下一轮按相反顺序再次查看所有未打开箱子。

题面没有明确说明初始方向。下面先按"初始方向固定为从左向右"回答；如果初始方向可以自行选择，分别模拟第一次从左向右和第一次从右向左，取可行方案中的最小反转次数即可。

为什么贪心是正确的

当一个箱子经过面前且满足 a[i] <= keys 时，立即打开它不会损害后续可行性：

这次操作只增加钥匙，不消耗会影响其他箱子的资源；
打开后增加的钥匙可能让本轮后续箱子立刻变得可开；
延迟打开不会带来更大的收益，反而可能错过同一轮的连锁增长。

因此，一轮扫描中遇到能开的箱子就立即打开，遇到暂时打不开的箱子就跳过并继续扫描。当传送带尚未走到端点时提前反转，相当于放弃当前方向后续所有可能打开的箱子；继续扫到端点不增加反转次数，钥匙数还只可能增加，所以提前反转不可能更优。这就证明了每轮完整地从一端扫到另一端存在最优解。

如果某一整轮没有打开任何箱子，钥匙数在轮前轮后完全相同。下一轮虽然顺序相反，但每个剩余箱子的需求都仍然大于当前钥匙数，因此也不可能打开任何箱子，必须判定无解。

算法

维护每个箱子是否已经打开、当前钥匙数 keys、扫描方向 direction 和反转次数 turns：

按当前方向遍历全部下标；
跳过已经打开的箱子；若未打开箱子满足 a[i] <= keys，立即打开并令 keys += 1；
一轮结束后，如果所有箱子都已打开，当前反转次数就是答案；
如果本轮一个箱子都没打开，返回不可行；否则反转方向并令 turns += 1。

python 复制代码

from typing import List, Optional, Tuple


def min_reversals_for_direction(a: List[int], direction: int) -> Optional[int]:
    """direction=1 表示首轮从左向右，direction=-1 表示首轮从右向左。"""
    n = len(a)
    opened = [False] * n
    opened_count = 0
    keys = 0
    turns = 0

    while opened_count < n:
        opened_this_round = 0
        indices = range(n) if direction == 1 else range(n - 1, -1, -1)
        for index in indices:
            if not opened[index] and a[index] <= keys:
                opened[index] = True
                opened_count += 1
                opened_this_round += 1
                keys += 1

        if opened_count == n:
            return turns
        if opened_this_round == 0:
            return None

        direction = -direction
        turns += 1

    return turns


def solve(a: List[int], initial_direction: Optional[int] = 1) -> Tuple[bool, int]:
    """
    返回 (是否可行, 最少反转次数)。
    initial_direction=1/-1 表示初始方向固定；传 None 表示两种初始方向均可选择。
    """
    if not a:
        return True, 0

    directions = (1, -1) if initial_direction is None else (initial_direction,)
    candidates = [
        turns
        for direction in directions
        if (turns := min_reversals_for_direction(a, direction)) is not None
    ]
    return (True, min(candidates)) if candidates else (False, -1)

成功方案中每轮至少打开一个箱子，所以最多扫描 n 轮；每轮检查 n 个位置，时间复杂度为 O(n^2)，记录打开状态的额外空间复杂度为 O(n)。这与题面中"n 很小，直接暴力正反扫"的约束一致。若题目给出很大的 n，才需要利用需求值和位置结构进一步优化，不能在缺少完整数据范围时虚构更复杂的必要性。

边界要说明三点：n=0 时答案为可行且反转次数为 0；钥匙需求为 0 的箱子在没有钥匙时也能打开；当一整轮没有任何箱子满足 a[i] <= keys 时，反转不会凭空增加钥匙，必须判定不可行。

第二题：

给定数组 a 和整数 k，选两个下标不同的元素，使 a $i$ + a $j$ 是 k 的倍数，求方案数（无序对）。

回答：

核心观察

当 k > 0 时，元素的具体数值只需要保留除以 k 的余数。设

r i = a i m o d k r_i = a_i \bmod k ri=aimodk

则

a i + a j ≡ 0 ( m o d k ) ⟺ r i + r j ≡ 0 ( m o d k ) . a_i+a_j\equiv 0\pmod{k} \quad\Longleftrightarrow\quad r_i+r_j\equiv 0\pmod{k}. ai+aj≡0(modk)⟺ri+rj≡0(modk).

余数 r 的配对余数是 (k-r) % k。因此：

余数为 0 的元素只能和余数为 0 的元素配对，贡献 C(cnt[0], 2)；
对于 1 <= r < k-r，余数 r 与 k-r 的方案数为 cnt[r] * cnt[k-r]；
如果 k 为偶数，余数 k/2 只能和自己配对，贡献 C(cnt[k/2], 2)。

"下标不同"由组合数 C(x, 2) 自然保证；"无序对"则意味着 (i,j) 和 (j,i) 只计算一次，不能在所有余数组合上直接把有序计数除以 2 后再处理特殊余数。

一次遍历的做法

还可以边遍历边统计。当前元素余数为 r 时，之前出现过且能与它配对的元素数量是 count[(k-r) % k]，把这个数量加入答案，再把 count[r] 加一。由于只向"之前的元素"配对，每一对下标恰好计数一次，天然满足无序计数和下标不同。

python 复制代码

from collections import defaultdict
from typing import List


def count_pairs(a: List[int], k: int) -> int:
    if k == 0:
        # 数学上"k 的倍数"要求 k 非零；若题目另有约定，应单独实现该约定。
        raise ValueError("k must be non-zero")

    k = abs(k)
    count = defaultdict(int)
    answer = 0
    for value in a:
        remainder = value % k
        complement = (-remainder) % k
        answer += count[complement]
        count[remainder] += 1
    return answer

例如余数序列为 [0, 0, 2, 2, 1, 3] 且 k=4，答案由 0 类内部配对、2 类内部配对和 1/3 跨类配对三部分组成，代码不会遗漏这些特殊情况。

时间复杂度为 O(n)；使用哈希表时额外空间复杂度为 O(min(n,k))，若 k 较小也可以使用长度为 k 的数组桶。Python 的 % 对负数仍会返回 [0, k-1] 范围内的非负余数，因此对负数组元素也成立。

第三题：

n 个点，m 条带权普通边（耗时 w），p 条耗时 0 的魔法边。

限制：全程最多用 k 次魔法边，且不能连续走两条魔法边。

允许自环和重边，求起点到终点最短用时。

回答：

为什么普通最短路状态不够

只记录"当前位于哪个点"会丢失两个会影响未来决策的信息：已经使用了多少次魔法边，以及上一条边是不是魔法边。同一个点、不同历史状态的后续可行边集合不同，所以必须把约束编码进状态。

定义分层图状态：

s t a t e = ( v , c , l a s t ) state=(v,c,last) state=(v,c,last)

其中 v 是当前点，c 是已经使用的魔法边数量，0 <= c <= k，last 为 1 表示上一条边是魔法边，为 0 表示不是。原图中的一个点会被复制成 2(k+1) 个状态点。

状态转移如下：

普通边 u -> v、耗时 w：

( u , c , l a s t ) → ( v , c , 0 ) , c o s t = w (u,c,last)\rightarrow(v,c,0),\quad cost=w (u,c,last)→(v,c,0),cost=w
魔法边 u -> v：只有 c < k 且 last = 0 时允许使用：

( u , c , 0 ) → ( v , c + 1 , 1 ) , c o s t = 0 (u,c,0)\rightarrow(v,c+1,1),\quad cost=0 (u,c,0)→(v,c+1,1),cost=0

起点为 (s,0,0)，终点可以是 (t,c,0) 或 (t,c,1) 的任意一层，因此答案是所有 c 和 last 状态距离的最小值。自环和重边不需要特殊处理：自环按普通转移或魔法转移处理，重边逐条保留即可；如果题目把边视为无向边，则输入时把每条边加入两个方向。

Dijkstra 实现

假设所有普通边耗时 w >= 0。因为魔法边权为 0、普通边权非负，扩展后的分层图没有负权边，可以直接运行 Dijkstra。不能仅因为存在 0 权边就改用 0-1 BFS；只有当所有边权都属于 {0,1} 时，0-1 BFS 才适用。

python 复制代码

from heapq import heappop, heappush
from typing import List, Tuple


def shortest_time(
    n: int,
    ordinary_edges: List[Tuple[int, int, int]],
    magic_edges: List[Tuple[int, int]],
    k: int,
    start: int,
    target: int,
) -> int:
    """点编号为 0..n-1；无路可达时返回 -1。"""
    if k < 0:
        return -1

    ordinary = [[] for _ in range(n)]
    magic = [[] for _ in range(n)]
    for u, v, weight in ordinary_edges:
        if weight < 0:
            raise ValueError("Dijkstra requires non-negative ordinary edge weights")
        ordinary[u].append((v, weight))
    for u, v in magic_edges:
        magic[u].append(v)

    # dist[vertex][used_magic][last_was_magic]
    inf = float("inf")
    dist = [[[inf, inf] for _ in range(k + 1)] for _ in range(n)]
    dist[start][0][0] = 0
    heap = [(0, start, 0, 0)]

    while heap:
        current, vertex, used, last = heappop(heap)
        if current != dist[vertex][used][last]:
            continue

        for nxt, weight in ordinary[vertex]:
            candidate = current + weight
            if candidate < dist[nxt][used][0]:
                dist[nxt][used][0] = candidate
                heappush(heap, (candidate, nxt, used, 0))

        if used < k and last == 0:
            for nxt in magic[vertex]:
                if current < dist[nxt][used + 1][1]:
                    dist[nxt][used + 1][1] = current
                    heappush(heap, (current, nxt, used + 1, 1))

    return min(dist[target][used][last] for used in range(k + 1) for last in (0, 1)) \
        if any(dist[target][used][last] < inf for used in range(k + 1) for last in (0, 1)) else -1

状态数为 O(nk)，每层都会扫描一次普通边和魔法边，所以边扩展规模为 O((m+p)k)；二叉堆实现的时间复杂度为

O ( ( m + p ) k log ⁡ ( n k ) ) , O\bigl((m+p)k\log(nk)\bigr), O((m+p)klog(nk)),

额外空间复杂度为 O(nk + (m+p))。如果 k 很大但实际最短路只会使用很少魔法边，可以按业务约束裁剪 k，但不能在没有证明的情况下随意截断，因为更高层状态可能确实产生更优解。

第四题：

左右各 N 匹马，battle $i$ $j$ = 1 表示左 i 胜右 j（配对得 +1 分），-1 则得 -1 分。

每匹马只能出战一次，两两配对后消失，求最大总得分。

回答：

二分图建模

左侧每匹马是一个顶点，右侧每匹马是一个顶点，battle[i][j] 是边 (i,j) 的权重。每匹马必须恰好参与一次配对，所以目标是求带权二分图的最大权完美匹配：

max ⁡ π ∈ S N ∑ i = 0 N − 1 b a t t l e $i$ $π ( i )$ \max_{\pi\in S_N}\sum_{i=0}^{N-1} battle $i$ $\\pi(i)$ π∈SNmaxi=0∑N−1battle $i$ $π(i)$

其中 \pi 是右侧马匹的一个排列。因为题目允许任意左右配对，图是一个完整二分图，至少存在一个完美匹配；自环和重边也不涉及，因为左右两侧是不同顶点集合。

本题 `+1/-1` 权值下的本质化简

如果总共配对 N 次，设其中有 W 次左马获胜，则有 N-W 次失败，总得分为：

s c o r e = W − ( N − W ) = 2 W − N . score=W-(N-W)=2W-N. score=W−(N−W)=2W−N.

所以最大化总得分等价于最大化能够同时实现的胜利配对数 W。构造一个只保留 battle[i][j] == 1 的二分图，求它的最大基数匹配，记匹配数为 W；然后把剩余的马任意配成剩余对即可。为什么剩余配对不会偷偷增加胜场？如果最大匹配完成后仍存在一条连接两个未匹配顶点的胜利边，就可以把这条边加入匹配，和"最大"矛盾。因此补齐的配对只能是失败边，最终得分确实为 2W-N。

这个化简比直接把四种情况写成贪心更可靠：局部选择一匹能赢的对手，可能抢走另一匹马唯一的胜利对象，必须由全局匹配决定。

通用解法：KM/匈牙利算法

如果未来权值不再局限于 +1/-1，例如得分包含不同的收益、平局或配对成本，就不能只数胜场，应使用带权完美匹配算法。KM 算法通过左、右顶标维护可行标号，在相等子图中寻找增广路；找不到增广路时调整顶标，最终得到最大权完美匹配，时间复杂度 O(N^3)。

下面给出适用于任意整数权值的匈牙利算法实现。它以最小费用版本为基础，将最大权转换为最小化负权，最后重新计算匹配权值，避免依赖实现中的内部势能符号。

python 复制代码

from typing import List, Tuple


def max_weight_perfect_matching(battle: List[List[int]]) -> Tuple[int, List[int]]:
    """
    返回 (最大总得分, assignment)。
    assignment[i] 是左侧 i 匹配到的右侧下标；要求 battle 是 N*N 方阵。
    """
    n = len(battle)
    if n == 0:
        return 0, []
    if any(len(row) != n for row in battle):
        raise ValueError("battle must be an N by N matrix")

    # Hungarian algorithm for minimum cost perfect assignment.
    # u[i] and v[j] are potentials; p[j] is the left vertex assigned to j.
    inf = 10**30
    u = [0] * (n + 1)
    v = [0] * (n + 1)
    p = [0] * (n + 1)
    way = [0] * (n + 1)

    for i in range(1, n + 1):
        p[0] = i
        min_value = [inf] * (n + 1)
        used = [False] * (n + 1)
        column = 0

        while True:
            used[column] = True
            row = p[column]
            delta = inf
            next_column = 0
            for candidate in range(1, n + 1):
                if used[candidate]:
                    continue
                cost = -battle[row - 1][candidate - 1]
                reduced = cost - u[row] - v[candidate]
                if reduced < min_value[candidate]:
                    min_value[candidate] = reduced
                    way[candidate] = column
                if min_value[candidate] < delta:
                    delta = min_value[candidate]
                    next_column = candidate

            for candidate in range(n + 1):
                if used[candidate]:
                    u[p[candidate]] += delta
                    v[candidate] -= delta
                else:
                    min_value[candidate] -= delta
            column = next_column
            if p[column] == 0:
                break

        while True:
            previous = way[column]
            p[column] = p[previous]
            column = previous
            if column == 0:
                break

    assignment = [-1] * n
    for right in range(1, n + 1):
        assignment[p[right] - 1] = right - 1
    score = sum(battle[left][assignment[left]] for left in range(n))
    return score, assignment

对本题的 +1/-1 矩阵，如果只需要总分，也可以实现"只保留胜利边的最大二分图匹配"，再返回 2 * matching_size - n；若使用 Hopcroft-Karp，复杂度可达到 O(E\sqrt{V})，这里完整二分图中的胜利边数最多为 N^2。KM/匈牙利算法则直接支持一般权值，O(N^3) 也符合题面给出的规模假设。

最后需要检查题意中的"每匹马只能出战一次"是否意味着必须把所有马都配完。上述答案按"左右各 N 匹全部两两配对"理解；如果题目允许弃权或不要求完美配对，就应增加"不配对"的 0 权虚拟节点，问题会变成最大权一般匹配/带弃权的分配问题，不能直接套用 2W-N。

总结：算法题的本质，是为约束找到最小充分状态

把四道题放在一起看，可以得到一条比具体模板更耐用的方法论。

第一步，先区分资源是消耗、保持还是单调增加。第一题中的钥匙不会因开箱而减少，所以"能开就开"具备交换论证基础；如果钥匙会被消耗，原贪心立即失效，状态中必须加入资源分配决策。

第二步，判断原始数值是否真的需要保留。第二题的目标只与模 k k k 的同余类有关，因此把整数压缩为余数不会丢失影响答案的信息。这类降维的关键不是"想到哈希表"，而是证明映射前后的可行对一一对应。

第三步，遇到路径附带次数、冷却、连续性或模式切换约束时，不要强行在原图上做普通最短路。第三题必须把"已经用了几次魔法边"和"上一条是否为魔法边"写进节点状态。只要两条到达同一点的路径拥有不同的后续可行集合，它们就不是同一个最短路状态。

第四步，警惕局部配对。第四题中的每一次选择都会同时占用左右两个顶点，局部最优可能抢走其他顶点唯一的胜利对象，因此必须使用全局匹配。权值恰好只有 + 1 / − 1 +1/-1 +1/−1 时可以化简为最大基数匹配；一旦加入平局、不同收益或弃权，模型就要回到一般最大权匹配。

面试或笔试现场不需要一开始就写出最漂亮的实现。更稳妥的回答顺序是：先明确题意歧义和输入边界，再给出状态与转移，随后证明正确性，最后写复杂度并指出算法失效条件。模板会过时，但这种从约束到状态、从状态到证明的能力不会过时。

【三年面试五年模拟】2026-09-06 拼多多 AI Agent研发岗秋招笔试4道算法题完整题解

写在前面

核心导读

笔试题与题解

第一题：

建模

为什么贪心是正确的

算法

第二题：

核心观察

一次遍历的做法

第三题：

为什么普通最短路状态不够

Dijkstra 实现

第四题：

二分图建模

本题 `+1/-1` 权值下的本质化简

通用解法：KM/匈牙利算法

总结：算法题的本质，是为约束找到最小充分状态

推荐阅读

1. 深入浅出完整解析AI Agent（AI智能体）的核心基础知识

2. 深入浅出完整解析扩散模型DDPM、DDIM、Score-Based、SDE、LDM、Classifier/Classifier-Free Guidance、Rectified Flow核心基础知识

3. 入浅出完整解析FLUX.2、Seedream（即梦）、Z-image、GLM-Image核心基础知识

4. 深入浅出完整解析FLUX.1 Kontext和FLUX.1 Krea核心基础知识

5. 深入浅出完整解析DeepSeek系列核心基础知识

6. 深入浅出完整解析Stable Diffusion 3（SD 3）和FLUX.1系列核心基础知识

7. 深入浅出完整解析Stable Diffusion XL（SDXL）核心基础知识

8. 深入浅出完整解析Stable Diffusion（SD）核心基础知识

9. 深入浅出完整解析Stable Diffusion中U-Net的前世今生与核心知识

10. 深入浅出完整解析LoRA（Low-Rank Adaptation）模型核心基础知识

11. 深入浅出完整解析ControlNet核心基础知识

12. 深入浅出完整解析Sora、Seedance、keling等AI视频大模型核心基础知识

13. 深入浅出完整解析AIGC时代Transformer核心基础知识

14. 深入浅出完整解析ComfyUI、Diffusers、Stable Diffusion WebUI等主流AIGC创作框架核心基础知识

15. 深入浅出完整解析ComfyUI、Diffusers、Stable Diffusion WebUI等主流AIGC创作框架核心基础知识

16. AIGC产业的深度思考与分析

17. AI算法工程师的独孤九剑秘籍

18. 深入浅出完整解析AIGC时代中GAN（Generative Adversarial Network）系列模型核心基础知识

【三年面试五年模拟】2026-09-06 拼多多 AI Agent研发岗秋招笔试4道算法题完整题解

写在前面

核心导读

笔试题与题解

第一题：

建模

为什么贪心是正确的

算法

第二题：

核心观察

一次遍历的做法

第三题：

为什么普通最短路状态不够

Dijkstra 实现

第四题：

二分图建模

本题 +1/-1 权值下的本质化简

通用解法：KM/匈牙利算法

总结：算法题的本质，是为约束找到最小充分状态

推荐阅读

1. 深入浅出完整解析AI Agent（AI智能体）的核心基础知识

2. 深入浅出完整解析扩散模型DDPM、DDIM、Score-Based、SDE、LDM、Classifier/Classifier-Free Guidance、Rectified Flow核心基础知识

3. 入浅出完整解析FLUX.2、Seedream（即梦）、Z-image、GLM-Image核心基础知识

4. 深入浅出完整解析FLUX.1 Kontext和FLUX.1 Krea核心基础知识

5. 深入浅出完整解析DeepSeek系列核心基础知识

6. 深入浅出完整解析Stable Diffusion 3（SD 3）和FLUX.1系列核心基础知识

7. 深入浅出完整解析Stable Diffusion XL（SDXL）核心基础知识

8. 深入浅出完整解析Stable Diffusion（SD）核心基础知识

9. 深入浅出完整解析Stable Diffusion中U-Net的前世今生与核心知识

10. 深入浅出完整解析LoRA（Low-Rank Adaptation）模型核心基础知识

11. 深入浅出完整解析ControlNet核心基础知识

12. 深入浅出完整解析Sora、Seedance、keling等AI视频大模型核心基础知识

13. 深入浅出完整解析AIGC时代Transformer核心基础知识

14. 深入浅出完整解析ComfyUI、Diffusers、Stable Diffusion WebUI等主流AIGC创作框架核心基础知识

15. 深入浅出完整解析ComfyUI、Diffusers、Stable Diffusion WebUI等主流AIGC创作框架核心基础知识

16. AIGC产业的深度思考与分析

17. AI算法工程师的独孤九剑秘籍

18. 深入浅出完整解析AIGC时代中GAN（Generative Adversarial Network）系列模型核心基础知识

本题 `+1/-1` 权值下的本质化简