京东2026春招笔试第三套：前缀和、DP与字典树全复盘

看到标题里写着“京东-2026.03.21-第三套”的时候，我第一反应是：又是一份考完就忘的笔试。但认真回忆了一遍，发现第三套题其实很有代表性，很适合拿去分析京东这类互联网大厂在春招笔试里的出题逻辑。这套题我投的是后端岗位，整体感觉是：选择题覆盖面广，编程题看起来都是“老朋友”，但每一道都埋了边界条件，不仔细真的容易掉分。下面按照我的考场记忆和赛后整理，把题目结构、解题链路、失分点、时间分配全部拆开讲。

1. 这套题的第一印象：题型分布与难度画像

1.1 整体题型与分值结构

先说总盘子。2026.03.21这场京东春招笔试，根据我拿到的那套题（第三套），考试时间是120分钟，题量不算夸张：单选题15题，多选题5题，编程题3题。分值分布大致如下：

这只是我记忆里的一个大概分配，不同批次可能有出入，但不影响用来判断节奏：选择题占大头，编程题虽然只有三题，但每题分值很高，绝对不能放弃。

1.2 第三套题的风格：重思维，轻模板

京东这套题给我的感觉是“重思维，轻模板”。三道编程题没有一道是那种直接套模板能过的裸题：第一题要的是对前缀和的变形理解，第二题是标准的线性DP但状态定义有讲究，第三题把树和前缀异或、最大异或对结合在一起。它不会直接问你“请写一个最短路径”，而是把常见算法换一层皮，考察你能不能认出本质。

这一点在后面的逐题复盘里会更明显。不过先给一个结论：这套题真正难的并不是算法本身，而是“在一个看似熟悉的题目里发现新约束”的能力。第一题的负数和整除条件、第二题的切换代价、第三题的树形结构，都是这一类的代表。

1.3 考后直观感受

我大概是考试结束前5分钟才把第三题的Trie写稳。第一题和第二题都遇到过程序本地跑得好好的、一提交就卡住的尴尬情况。第一题是因为负数取模没有修正，第二题是因为某个样例的收益是负数，导致初始状态从0开始算会得出错误结果。后面我会把这些细节单独拎出来，因为这种问题复盘价值极高。整体来说，这套题想拿到及格分不难，但想拿高分，必须对代码细节有足够强的敏感度。

2. 编程题逐题复盘：题目还原与解题链路

2.1 第一题：连续子段和能被K整除——同余才是核心

题目大意是这样：给一个长度为n的整数数组a，再给一个正整数k，要求找出最长的连续子数组，使得这个子数组的元素和能被k整除。数据范围是n ≤ 2×10^5，k ≤ 10^5，数组元素可能为负。输出最长长度，如果不存在则输出0。

这题暴力做是O(n^2)，n到2e5直接超时。正确的开法是前缀和加同余。

设pre[i]表示a[0]到a[i-1]的前缀和，那么子数组a[l]到a[r-1]的和就是pre[r] - pre[l]。题目要求这个差能被k整除，数学上等价于pre[r] % k == pre[l] % k。注意这里取模要对负数做修正，C++和Java的负数取模结果还是负数，必须把它调整到[0, k-1]区间。

所以思路就清晰了：遍历前缀和，用哈希表记录每个余数第一次出现的位置，当前余数如果已经在表里，就用当前位置减最早位置，更新答案；如果没出现过，才把当前位置存进去。

核心代码（C++风格）：

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

int main() {
    int n, k;
    cin >> n >> k;
    vector<int> a(n);
    for (int i = 0; i < n; i++) cin >> a[i];

    unordered_map<int, int> first;
    first[0] = 0; // pre[0] = 0
    int cur = 0, ans = 0;
    for (int i = 0; i < n; i++) {
        cur = (cur + a[i]) % k;
        if (cur < 0) cur += k;
        if (first.count(cur)) {
            ans = max(ans, i + 1 - first[cur]);
        } else {
            first[cur] = i + 1;
        }
    }
    cout << ans << endl;
    return 0;
}

这里最容易踩的坑有三个：

• 忘记把pre[0]=0这个初始余数放进去。如果不放，从数组开头开始的子数组永远统计不到。
• 更新哈希表时，只用最早出现的位置，不要用最近出现的位置。因为求的是最长长度，位置越早、间隔越大。
• 负数取模必须修正。a[i]本身是负数时，cur + a[i]可能变成负数，%k后还是负数，不修正会直接影响first表的查找。

为了看清楚，用一个手算样例：

code复制n = 7, k = 3
a = [2, 3, 1, 5, 4, 0, 1]

前缀和是[0, 2, 5, 6, 11, 15, 15, 16]，对3取模后是[0, 2, 2, 0, 2, 0, 0, 1]。第一次出现余数0的下标是0，最后一次出现余数0的下标是6，所以最长子数组长度为6。对应的就是a[0]到a[5]这段，和是15，能被3整除。这个例子里，如果漏掉初始下标0，最长就能只能算到4，答案直接错。

至于空间，理论上余数最多k种，哈希表大小不会超过k，时间O(n)，空间O(min(n, k))。这一题做出来不算难，但能一次拿满的人不多，大多挂在负数和首位置这两个细节上。

2.2 第二题：双任务切换DP——定义状态比堆公式更重要

第二题是一道动态规划。题目大概是这样：未来n天，你每天可以安排做A任务或B任务，第i天做A任务能获得a[i]收益，做B任务能获得b[i]收益。但如果某一天做的任务和前一天不一样，需要支付一次切换成本c。第一天不需要成本。求n天最大总收益。n ≤ 10^5，c ≥ 0。

这题的核心是“昨天的选择会影响今天”，但只影响相邻两天，所以二维状态就够了。状态定义：

dp[i][0]：第i天结束时，最后一天做的是A任务，能获得的最大收益。
dp[i][1]：第i天结束时，最后一天做的是B任务，能获得的最大收益。

转移就两种情况：今天继续做和昨天一样的任务，没有额外成本；今天切换任务，要减掉c。写成状态转移就是：

code复制dp[i][0] = max(dp[i-1][0], dp[i-1][1] - c) + a[i]
dp[i][1] = max(dp[i-1][1], dp[i-1][0] - c) + b[i]

初始化时，第一天做A就是a[0]，做B就是b[0]，没有切换成本。为了避免负数状态干扰，第一天之前的dp可以设为负无穷，然后单独处理第一天，或者直接把dp[0][0]=a[0], dp[0][1]=b[0]开始循环。

这里有个很重要的点：dp值可能为负数。如果天数的收益全是负数，你还必须每天选一个任务做，那最优解可能是负数。如果题目允许“某天不做”，那还要再加一个空状态，但京东这道题根据我的记忆是要求每天必须安排一个任务，所以不能用0来初始化第一天。

面试笔试里最怕的不是写不出转移方程，而是把“切换代价”加到错误的位置。有同学会把切换成本写进收益里，比如今天切了就减c，但写成dp[i][1] = max(dp[i-1][1], dp[i-1][0]) + b[i] - c，这样看起来也对，但问题在于当“昨天做A今天做B”和“昨天做B今天做B”比较时，后者也被错误减了c。正确写法应该是只有从另一种任务转移过来时才扣代价。

这里也体现了一个通用原则：线性DP的转移，要按“每一条转移边”分别写，不要用一个统一的公式掩盖不同边的费用差异。否则数据一强就会翻车。

滚动数组版本可以这样写：

cpp复制long long dp0 = a[0], dp1 = b[0];
for (int i = 1; i < n; i++) {
    long long ndp0 = max(dp0, dp1 - c) + a[i];
    long long ndp1 = max(dp1, dp0 - c) + b[i];
    dp0 = ndp0;
    dp1 = ndp1;
}
cout << max(dp0, dp1) << endl;

注意用long long。a[i]和b[i]的绝对值可能到1e9，n到1e5，收益累加后完全可能超过int上限。这一点也是本地测试看不出来的，只有提交后WA或者爆内存才会发现。

复杂度O(n)，空间可以优化成O(1)。笔试里开两个n维数组也能过，但我会顺手滚动，主要为了显得专业，也能防一手内存限制比较变态的情况。

2.3 第三题：树上的最大异或路径——把树变成数组再用字典树

第三题显然是用来拉开差距的。题目大意：给一棵n个节点的树，每条边上有一个非负整数权值，定义一条简单路径的价值为路径上所有边权的异或和，求所有路径中价值的最大值。n ≤ 2×10^5，边权小于2^30。

拿到这题，第一步要想到一个关键性质：设根节点为1，记xorSum[u]为从根到u路径上的边权异或和。那么对于任意两个节点u和v，它们之间的路径异或和就是：

code复制xorSum[u] xor xorSum[v]

为什么？因为根到u、根到v这两条路径，从根到lca(u,v)的公共部分是重复的，异或同一个数两次会抵消，剩下的正好是u和v之间那条唯一简单路径的异或和。

所以问题瞬间从树上路径问题变成了一个数组问题：给n个数，求其中两个数异或的最大值。这是经典的最大异或对问题，用二进制Trie（字典树）解决。从高位到低位贪心，对于当前数，优先走和它的当前位相反的位，因为异或结果这一位是1，必然比0大。

参考代码（Python描述思路，笔试时用C++也可以）：

python复制class Trie:
    def __init__(self):
        self.child = {}
    def insert(self, num):
        node = self.child
        for b in range(29, -1, -1):
            bit = (num >> b) & 1
            if bit not in node:
                node[bit] = {}
            node = node[bit]
    def query(self, num):
        node = self.child
        res = 0
        for b in range(29, -1, -1):
            bit = (num >> b) & 1
            rev = 1 - bit
            if rev in node:
                res |= (1 << b)
                node = node[rev]
            else:
                node = node[bit]
        return res

主流程：先DFS一次，算出所有xorSum[u]；然后初始化一个空Trie，先插入0，接着遍历每个节点u，查询xorSum[u]能得到的最大异或值，再把xorSum[u]插入Trie。最后答案取所有查询结果的最大值。

这里我特别强调一下：一定要先插入0。因为路径可能是从一个节点到它的某个子孙，也可以理解成从根到某个祖先路径的一段，插入0后，查询时才能把“xorSum[u]异或0”也就是根到u的整条路径纳入考虑。如果题目规定路径必须至少有一条边，那这个细节可以通过最后判断处理；但从数据范围看，多数情况下答案至少是单条边权值，插入0不影响最终最大值的正确性。

这道题还有一个容易忽略的点：DFS的递归深度。n达到2e5，如果图是一条链，递归栈直接爆了，所以现场最好改成迭代DFS或使用C++里手动开栈。这也是为什么很多人样例能过、提交就栈溢出的原因。

2.4 复盘：三道题的递进关系

这三道题其实是递进的：第一题考基础数据结构变形，第二题考状态设计，第三题考问题转换能力。如果第三题能想到预处理异或前缀，说明你对“异或抵消”这个性质很敏感；如果还能实现Trie，那就稳了。建议复盘的时候不要只看自己AC没有，而是看哪一步是卡住的。卡在第一步“想不出前缀和”的人，要多练前缀和变形；卡在Trie实现的，就单独把这个结构写三遍，写到能不查板子。

3. 选择题非算法环节：从考点到蒙题策略

3.1 考点分布与复习权重表

第三套题的选择题，个人感觉比编程题更“阴”。不是因为难，而是因为考了很多平时不一定会看的边角知识。我整理了个大概分布：

从这个分布能看出来，语言基础占比最大。如果你投的是Java后端，至少要把Java语法和JVM基础过一遍；如果投C++岗位，那智能指针、虚函数、const各种用法都要熟。选择题的复习不太需要刷难题，重点是把常见概念记清楚。

3.2 三道印象深刻的代码输出题

这里挑三道我印象比较深的题，还原一下出题角度。

第一道是Java的null打印。代码大概是这样：

java复制Object obj = null;
System.out.println(obj);

很多人第一反应是抛NullPointerException，但实际输出是字符串"null"。原因在于PrintStream.println(Object)方法内部会先判断obj == null，如果为空就直接打印字符串"null"，不会调用obj.toString()。这道题就是纯坑，没踩过就是没踩过，考完赶紧记下来比蒙对更有价值。

第二道是synchronized锁的粒度。题目给了两个线程，分别调用同一个对象上的同步方法和普通方法，问是否有竞争。答案是没有竞争，因为普通方法根本不会去拿对象锁。这种题在本地跑可能一百次都复现不出来，但考的就是对锁机制的理解。我的经验是不要试图“背输出”，而是画一条时间线，标清每个线程进入和退出临界区的时刻，然后按顺序推。

第三道是C++的delete和delete[]。题目问动态分配的数组如果用delete释放会导致什么。答案是未定义行为，但选择题里通常会给一个“可能崩溃”的选项，偶尔还会出现“编译器报错”这个干扰项。记住一个结论：new[]必须配delete[]，new必须配delete，这是笔试选择题最常考的无聊但重要的细节。

3.3 多选题的取舍策略

多选题的规则通常是少选得部分分、多选错选不得分。我的策略很保守：只选100%确定的选项。遇到那种“说得很绝对”的选项，比如“HashMap一定比TreeMap快”，直接不选。在时间有限的情况下，宁可少拿一半分，也不要因为一个不确定选项丢掉整题。笔试不是竞赛，得分率优先。

4. 实战策略：从答题顺序到防坑清单

4.1 我的答题顺序与依据

我用的顺序是“先做选择题，再做编程题”，但中间有个小技巧：选择题每道题控制在1分钟内，超过1分钟就标记跳过，先把能拿的分拿到。15道单选加5道多选，整体尽量控制在30分钟以内。剩下90分钟，编程题每道题分配25分钟，最后留15分钟做检查。

为什么要先做选择题？因为编程题如果卡住，会非常占用时间，反而容易把后面简单选择题的时间挤掉。选择题是“平均得分率”更高的部分，优先把它稳定拿住，心理上也更稳。

编程题顺序上，我建议按题目编号做，或按通过难度预估。如果发现第一题读题都吃力，先跳过去看后面两题，回来再做也是可以的。京东这套题的第一题其实最容易，但考场状态不好的时候，读题都可能读偏，这时候别硬扛。

4.2 本地编译器和OJ的差异

京东这套题用的是牛客或类OJ系统，本地IDE和OJ之间存在几个非常经典的差异：

• 数据读取：本地测试样例没问题，但提交后出现“段错误”，大概率是数组越界。写代码时把下标从0还是从1搞清楚，尤其是前缀和数组，长度是n+1不是n。
• int溢出：第二题dp值可能超过2^31-1，必须用long long。第三题的异或结果虽然单个不超过2^30，但中间变量也别省。
• 多组输入：部分平台会要求处理多组测试数据，代码要写成while(cin >> n)的形式，否则只跑第一组。

有个通用习惯：在提交前把数组长度、循环边界、输入变量类型这三项单独检查一遍。我这次第一题出问题，就是因为数组长度写成了n而不是n+1，本地几组样例恰好没越界，提交后直接崩。

4.3 调试策略：从暴力到优化

编程题如果没思路，我建议先写一个能跑出正确结果的暴力版本，小数据跑通，再去想优化。不是浪费时间，而是用暴力结果当标尺。第二题我就先用O(n^2)版本验证状态转移对不对，再改成O(n)的滚动数组，这样能保证优化过程不引入新错误。第三题如果Trie写不熟练，也可以先用暴力O(n^2)在样例规模不大的情况下拿部分分，至少有保底。

还有一个小技巧：构造极端边界样例。第一题试k=1、数组全为负数、单个元素；第二题试c=0、n=1、收益全为负；第三题试n=2的简单树、树退化成链。这些边界情况不需要跑OJ，在自己脑子里过一遍，就能发现大部分低级错误。

5. 考后复盘：京东笔试出题倾向与后续准备

5.1 高频考点雷达

复盘完整套题，我对京东春招笔试的考点倾向有了更具体的判断：

• 前缀和、哈希表：几乎必考，而且不只是裸前缀和，喜欢套上“同余”“异或”“差值”等变形。
• 线性DP：必考一道，状态转移不复杂，但边界和代价处理必须严谨。
• 树/图论：大概率有一道，不一定考最短路或最小生成树，更可能是DFS、前缀异或、直径、LCA等“树上思维题”。
• 语言细节：Java或C++的底层机制题频繁出现，建议复习String常量池、线程锁、HashMap底层、垃圾回收这几个点。

这套第三题的最大启发是：树的遍历只是基础，真正拉开差距的是“把树上问题通过异或/差分的性质转换成数组问题”的能力。这种题在LeetCode上通常被标为Hard，但核心步骤其实很朴素，就是找到那个让题目“变简单”的等式。

5.2 刷题建议

如果目标是京东或同级别大厂的后端岗位，不要把时间花在刷偏题怪题上。我的建议是按专题过，每个专题刷到能独立讲清楚思路为止：

• 数组：前缀和、差分、滑动窗口、双指针。
• 字符串：哈希、回文、模拟。
• DP：线性DP、背包、区间DP、状态机DP。
• 树：DFS、BFS、直径、LCA、树上差分、异或前缀。
• 二分：二分答案、二分查找变形。
• 图：最短路、并查集、拓扑排序。

每天可以安排2道新题加1道复盘的旧题，重点不是刷了多少，而是每道题都能说清楚“为什么这么做”。

5.3 心态层面的建议

笔试刷多了你会发现，能AC的题大家都能AC，拉分的题往往不是真的不会，而是“明明会但没注意到边界条件”。考场上最亏的不是难题不会做，而是简单题因为粗心丢分。所以考完复盘比考前突击更重要，把这次丢分点写进错题本，下次笔试前翻一遍，效果比临场看十道新题都好。

就个人体验来说，这套题的代码实现难度并不高，真正决定分数的其实是“稳定”。第一题5行核心逻辑，但漏一个负数取模就全错；第二题状态转移写对了，但初始化用0也可能踩坑；第三题思路想到之后，剩下的就是基本功。如果你也准备面这类大厂，建议多在这种“简单算法、复杂边界”的题上花时间，性价比最高。