网易2019实习生招聘编程题全解析：考点、代码与考场策略

每年到这个时间点，总有一批准备暑期实习的同学开始在牛客网上刷题。最近好几个学弟学妹跑来问我同一个问题：网易的笔试到底难不难？我的回答一般是：你去把《网易2019实习生招聘编程题集合》从头到尾过一遍就知道了。这套题流传很广，几乎成了大厂实习笔试的入门样本。它整体难度不劝退，没有那种一上来就甩你一道后缀自动机的硬核题，但每一道都不白给，模拟题的边界条件、数学题的规律总结、贪心题的严格证明，每一样都能筛掉一批人。这篇文章我就把这套题完整拆开，从考点到代码到坑位，按我自己的做题顺序全部过一遍，最后再聊聊考场上的时间分配和做题策略，给准备参加大厂实习笔试的同学一个可以参考的路径。

1. 网易2019实习生笔试：这批题到底在筛选什么样的人

1.1 八道题的考点分布与整体风格

先看整体结构。这套题在牛客网上一共八道，考得非常集中：

你会发现网易这批题几乎没有考复杂数据结构和冷门算法，什么线段树、树状数组、KMP、并查集全部没有，核心就四个字：逻辑、数学。前两道题纯粹考你会不会把现实场景抽象成代码，中间几道题考的是你愿不愿意先动笔推导再动手写码，最后两道题稍微上强度，但也就是折半搜索和线性DP的范畴，属于认真刷过题的同学都应该见过的套路。

1.2 为什么这套题值得反复刷

我对这套题的评价是：它是一套非常典型的“大厂海选题”。海选阶段不是要招天才，是要把两类人筛掉：一类是只会背模板、题目稍微换个包装就认不出来的，另一类是基础不扎实、老是挂在边界条件上的。这两类人在这套题里会死得很难看。

举个例子，牛牛的闹钟那道题，很多人一看到时间就想到用字符串处理，硬生生把一道水题写成大模拟，最后还因为前导零问题WA了两次。用整数分钟数换算它不香吗？这就是典型的“认不出包装”。再比如被3整除那道题，暴力解法在数据小的时候能过，但题目把区间范围拉到10^9量级，就是逼你去找规律，如果一上来就无脑for循环，等超时提示弹出来再回头看题，几十分钟就没了。

所以这套题真正的价值在于：它用八道题把笔试中最常见的几类陷阱全部覆盖了一遍，而且每道题都有不止一种做法。刷这套题不是刷完就完事了，你得把每道题的“为什么这么做”想透，然后再去找同类题巩固。

2. 两道模拟题：闹钟和迷路，边界条件才是真正的考点

2.1 牛牛的闹钟：一切时间问题先换算成分钟

题目大意是：牛牛定了N个闹钟，他起床后需要X分钟才能到教室，上课时间是当天的A时B分。问他在不迟到的前提下，最晚可以定在哪个闹钟时间起床。输入输出都是“时 分”的格式。

我的第一反应是：所有时间全部换算成“从零点开始的分钟数”，没有第二种做法。小时乘以60加分，再加上起床后需要的X分钟，得到“这个闹钟响时到达教室的时间”。然后从所有闹钟里挑出到达时间不大于上课时间的最大值，把这个闹钟的原始时间输出。

import java.util.*; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int n = in.nextInt(); int[] alarm = new int[n]; for (int i = 0; i < n; i++) { int h = in.nextInt(); int m = in.nextInt(); alarm[i] = h * 60 + m; } int x = in.nextInt(); int classTime = in.nextInt() * 60 + in.nextInt(); int ans = 0; for (int i = 0; i < n; i++) { if (alarm[i] + x <= classTime) { ans = Math.max(ans, alarm[i]); } } System.out.printf("%d %d\n", ans / 60, ans % 60); } }

这个题有没有坑？有。第一个坑是“最晚”这两个字，很多人第一遍读题只注意到“不能迟到”，直接输出最后一个满足条件的闹钟，忘了先排个序。虽然题目样例里闹钟是按时间顺序给的，但没有明确说明输入一定有序，稳妥起见还是先排序或者像上面代码一样直接取最大值。第二个坑是输出格式，前导零的问题在牛客上一般是允许的，但用printf格式化输出总是最保险的。第三个坑比较隐蔽，就是X可能很大，闹钟时间加上X之后可能超过24小时，不过题目限定是同一天上课，所以只要判断小于等于上课时间就行，不用处理跨天。

2.2 迷路的牛牛：方向状态机怎么写不出Bug

第二道模拟题是牛牛从家出发先向东走，然后转N次方向，每次要么左转L要么右转R，问最后面向哪边。这道题比闹钟还简单，但错的人也不少，问题基本出在方向数组的取模上。

我习惯用四个数字表示朝向：0代表东，1代表南，2代表西，3代表北。为什么这么定？因为右转是顺时针方向，对应数值加1；左转是逆时针，对应数值减1。然后统一用加4再取模的方式处理负数。

import java.util.*; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int n = in.nextInt(); String s = in.next(); String[] dir = {"E", "S", "W", "N"}; int cur = 0; // 0:E 1:S 2:W 3:N for (char c : s.toCharArray()) { if (c == 'R') cur = (cur + 1) % 4; else cur = (cur + 3) % 4; // 等价于减1再取模 } System.out.println(dir[cur]); } }

这里有一个很容易被忽略的细节：cur = (cur - 1 + 4) % 4写成(cur + 3) % 4，在普通情况下没问题，但如果你让别人review你的代码，还是写成cur = (cur - 1 + 4) % 4更清晰。我在这道题上想提醒的不是取模，而是刷题时拿到这种“转方向”的题目，第一件事不是在草稿纸上画坐标轴，而是先把方向数组和数值映射定义好。很多同学在面试时一紧张，就在代码里直接写死四个if分支，一旦方向多了或者要连续处理，就会漏分支。用状态机的方式写，逻辑全部收敛在一行里，反而最不容易出错。

3. 数学规律题：被3整除与数对，把枚举问题变成公式推导

3.1 被3整除：从数字和到步长为3的规律

题目描述了一个神奇数列：第1项是1，第2项是12，第3项是123，第4项是1234，依此类推。问这个数列的第l项到第r项里，有多少项能被3整除。数据范围很大，l和r可以到10^9，摆明了不让你逐项判断。

能整除3的充要条件是各位数字之和能被3整除。那么第i项的数字和是多少？它是1到i的所有数字加起来，也就是i(i+1)/2。这个结论一出来，问题就变成了：判断i(i+1)/2是否整除3。注意这里的关键点，i和i+1是两个连续整数，它们相乘一定有一个是偶数，所以i(i+1)/2一定是整数，这也是为什么这个数列的每一项一定都是整数拼接而成，不会有分数的问题。

接下来找规律。我不喜欢凭空记结论，所以当时是在草稿纸上老老实实列了前几项：

• i=1：数字和=1，不整除3
• i=2：数字和=3，整除3
• i=3：数字和=6，整除3
• i=4：数字和=10，不整除3
• i=5：数字和=15，整除3
• i=6：数字和=21，整除3

规律已经很明显了：每三个数里有两个能被3整除，具体来说，i模3余1的时候不行，模3余0或2的时候都行。所以1到r这段区间里，不能被整除的数量就是那些i模3余1的数，数量是(r + 2) / 3，能被整除的数量就是r - (r + 2) / 3。区间变成前缀和做差：

import java.util.*; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); long l = in.nextLong(); long r = in.nextLong(); System.out.println(calc(r) - calc(l - 1)); } static long calc(long x) { return x - (x + 2) / 3; } }

这道题想说的经验是：凡是遇到“一个数列从第l项到第r项有多少个满足某性质”这种问题，第一反应不要是遍历，而是先求出“第i项的通项表达式”，再找“满足性质的条件”，最后用前缀和做差O(1)出答案。这才是出题人真正想考的东西。

3.2 数对：枚举y，用商和余数计算贡献

数对这道题描述起来很简单：给一个n和一个k，问有多少个正整数数对(x, y)满足x和y都不大于n，并且x mod y的值不小于k。n和k的范围很大，暴力是O(n^2)必死。

我的第一直觉是枚举y。因为一旦固定了y，x mod y的取值就有周期性，可以分类讨论。这里先考虑特殊边界：如果k等于0，那么任何x mod y都大于等于0，答案就是n的平方。这个特判不加，后面所有枚举逻辑都会出问题，因为k=0时，y从1开始枚举，单个周期内满足条件的个数变成了y个，会导致答案对不上。

当k大于0时，x mod y >= k意味着余数不能为0，所以y至少是k+1，否则x mod y最大是y-1，一定小于k，可以直接跳过。固定y之后，x从1到n，每个周期长度是y，余数序列是1,2,...,y-1,0循环。一个完整周期里，满足余数不小于k的有y-k个数（余数k到y-1）。n里面完整周期有n/y个，贡献是(n/y)*(y-k)。剩下n%y个数字，对应余数1到n%y，贡献是max(0, n%y - k + 1)。

import java.util.*; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); long n = in.nextLong(); long k = in.nextLong(); if (k == 0) { System.out.println(n * n); return; } long ans = 0; for (long y = k + 1; y <= n; y++) { long full = n / y; long rest = n % y; ans += full * (y - k); if (rest >= k) { ans += rest - k + 1; } } System.out.println(ans); } }

这道题最容易踩的坑就是k=0。我当年刷的时候，自认为考虑得很全面，结果提交上去WA，查了半天才发现是k=0导致公式里的y - k变成了y，而后面的rest - k + 1也变了，整个累加逻辑就错了。所以遇到这种带参数的数学题，先看看参数能不能取到边界值，边界值往往就是出题人埋的雷。

4. 贪心题：安置路灯与俄罗斯方块，关键在于证明局部最优就是全局最优

4.1 安置路灯：每个点亮的坑位都该被右侧路灯覆盖

这道题是典型的区间覆盖贪心。一条长度为n的路，用字符串表示，'.'表示需要照明，'X'表示障碍物不需要照明。一个路灯能照亮自己所在位置以及左右相邻各一个位置，问最少放多少个路灯。n可以达到1000，暴力搜索是不可能的。

贪心策略是：从左往右扫描，遇到第一个需要照明的点，就把路灯放在它右侧相邻的位置，然后跳过三个位置。为什么放右侧而不是放在当前点？因为左侧已经全部被处理过了，灯放在当前点只能覆盖当前点和右边第一个点，放在右边第一个点则能覆盖当前点、右边第一个点、右边第二个点，右边多赚一个位置的覆盖。所以从全局来看，从左往右处理时，“放在当前位置的右侧”永远不劣于放在当前位置，这就是贪心选择性质的证明。

import java.util.*; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int T = in.nextInt(); while (T-- > 0) { int n = in.nextInt(); String s = in.next(); int ans = 0; for (int i = 0; i < n; ) { if (s.charAt(i) == '.') { ans++; i += 3; } else { i++; } } System.out.println(ans); } } }

这个题有个非常经典的误区：有人觉得应该优先在当前点放灯，因为这样当前点一定被覆盖。这种想法错在忽略了“当前点左侧已经被覆盖”这个前提。每次遇到第一个未覆盖的亮灯点，它左边一定是已经处理完的区域，所以放右边不会留下任何左边漏网之鱼。只要把这句话想明白，贪心就站得住脚。另一个容易错的地方是i += 3的位置，因为灯放在i+1，覆盖范围是i、i+1、i+2，所以下一个需要检查的位置是i+3，而不是i+2，很多人在这一步写错边界。

4.2 俄罗斯方块：平均分配思维，别真的去堆方块

这道题的原题描述是：屏幕下方宽度为n列，有m个方块依次从上方落下，每个方块会掉落到当前高度最低的那一列，如果有多列高度相同，选择最左边的一列。每落一个方块，该列的分数加1。问最终屏幕上的最高分数是多少。

大部分人的第一反应是用一个小顶堆模拟：每次弹出堆顶，也就是当前最矮的那一列，让它加1再放回去。这样复杂度是O(m log n)，m如果到10^9直接爆炸。但是如果你理解了“每次都让全局最矮的列加1”这个操作，就会发现这其实就是一个均摊过程：n列的高度永远只会相差1。最终m个方块被分配到了n列上，最高的列拿到的是ceil(m/n)。

import java.util.*; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int n = in.nextInt(); int m = in.nextInt(); System.out.println((m + n - 1) / n); } }

这道题的价值在于它提醒我们：写代码之前先花30秒想想，题目给的模拟过程最终会收敛到什么状态。如果每一步操作都是“当前全局最小值加1”，那么整个过程等价于往n个桶里轮流倒水，不管顺序如何，最终各桶高度差不会超过1。这种题在笔试里属于“看着像数据结构，其实是脑筋急转弯”的类型。你如果一上来就写堆，数据大的时候照样超时，最后还觉得自己算法没错，其实是被题目包装骗了。

5. 牛牛的背包问题：30件零食的大容量背包，折半搜索是正解

5.1 为什么普通01背包做不了

题目是：牛牛背包容量为w，家里有n袋零食，每袋体积为v[i]，问在总体积不超过w的情况下有多少种放法，包括什么都不放的那种。乍一看是01背包求方案数，但仔细看范围：n最大30，w最大可以到2^31-1。如果用经典的DP，dp数组开不下，因为容量太大；就算开得下，复杂度也是O(n*w)，w都是int上限了，完全不可行。

这里要有一个条件反射：当n很小（30左右）但每个物品的体积或背包容量很大的时候，折半搜索比背包DP更合适。因为n=30意味着总子集数是2^30，大约10亿，直接枚举肯定超时。但把30个物品分成两半，每边15个，子集数就是2^15=32768，这个规模完全可以接受。

5.2 折半搜索的完整实现思路

第一半枚举出所有可能的子集和，放进一个数组里排好序。第二半每枚举出一个子集和s2，就在第一半的数组里二分查找有多少个元素小于等于w - s2，累加进答案。这样做的正确性在于：任意一个合法的全局装法，都可以看作“第一半的某个子集”和“第二半的某个子集”的并集，而且两半是独立的，总容量不超过w，所以第一半的子集和必须小于等于w - s2，二分就是在统计满足这个条件的数量。

import java.util.*; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int n = in.nextInt(); long w = in.nextLong(); long[] v = new long[n]; for (int i = 0; i < n; i++) { v[i] = in.nextLong(); } int mid = n / 2; List<Long> left = new ArrayList<>(); List<Long> right = new ArrayList<>(); dfs(v, 0, mid, 0L, left); dfs(v, mid, n, 0L, right); Collections.sort(left); long ans = 0; for (long s : right) { if (s <= w) { ans += upperBound(left, w - s); } } System.out.println(ans); } static void dfs(long[] v, int idx, int end, long sum, List<Long> out) { if (idx == end) { out.add(sum); return; } // 不选当前零食 dfs(v, idx + 1, end, sum, out); // 选当前零食 if (sum + v[idx] <= Long.MAX_VALUE) { dfs(v, idx + 1, end, sum + v[idx], out); } } static int upperBound(List<Long> list, long target) { int l = 0, r = list.size(); while (l < r) { int mid = (l + r) >>> 1; if (list.get(mid) <= target) { l = mid + 1; } else { r = mid; } } return l; } }

这里有两个细节。第一，所有变量包括dfs里的sum都要用long，因为w最大是2^31-1，两个子集和加起来很可能超过int范围。第二，递归边界条件里我故意写了一个sum + v[idx] <= Long.MAX_VALUE的判断，其实当n只有30、体积是int范围时不会溢出，但这个习惯建议保留，因为折半搜索一旦扩展到更多物品，溢出是真实存在的风险。

5.3 这题的扩展与考场取舍

如果面试官把n改成40，折半搜索还能不能做？可以。40个物品分成两半就是2^20，大约100万，排序和二分依然在可接受范围内。如果再大到50，那就得考虑用“按体积排序后DFS剪枝”的做法，或者用双向搜索配合双指针优化。这就引出一个很重要的应试经验：看到n是30、40这种“暴力会超但又不完全超”的规模，优先想折半搜索；看到n是1000以上，才考虑优化的DP或贪心。这个判断不需要很精确，但能帮你快速锁定正确的算法方向。

6. 牛牛的数列：最长连续递增子序列的“改一个数”变体

6.1 预处理左递增和右递增

题目要求：在一个数列中找一个最长的连续子序列，要求这个子序列最多改变一个数之后能变成严格递增的。变化一下就是：你可以最多修改原序列中的一个值，然后找最长的严格递增连续子串。注意这里是“连续子序列”，不是可以跳着选的那种，所以不能直接套LIS，应该往连续子串的方向想。

经典做法是预处理两个数组：left[i]表示以位置i结尾的最长严格递增连续段的长度，right[i]表示以位置i开头的最长严格递增连续段的长度。这两个数组都可以在O(n)内递推出来：left[i]在a[i]大于a[i-1]时等于left[i-1]加1，否则等于1；right[i]在a[i]小于a[i+1]时等于right[i+1]加1，否则等于1。

6.2 枚举被修改的位置

预处理完之后，枚举每一个可能被修改的位置i。修改a[i]的目的是让它同时衔接上左边的递增段和右边的递增段。如果a[i-1] < a[i+1] - 1，说明我一定能构造出一个新的值放在a[i]的位置，使得左边以a[i-1]结尾的段、a[i]自己、右边以a[i+1]开头的段能合并成一段，长度就是left[i-1] + 1 + right[i+1]。

如果a[i-1]和a[i+1]之间没有整数空间，比如a[i-1]=3、a[i+1]=3，那么改a[i]不可能同时接上两边，只能选择保留左边段加上自己，或者保留自己加上右边段，取两者较大的那个。还有一种情况，i是端点，比如i=0，那么直接改a[0]就能接上右侧段，长度就是right[1] + 1（如果n>1的话）；所有情况都枚举完，再和“一个数都不改”的最长段长度比较，取最大值。

import java.util.*; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int n = in.nextInt(); int[] a = new int[n]; for (int i = 0; i < n; i++) { a[i] = in.nextInt(); } if (n <= 2) { System.out.println(n); return; } int[] left = new int[n]; int[] right = new int[n]; left[0] = 1; for (int i = 1; i < n; i++) { left[i] = (a[i] > a[i - 1]) ? left[i - 1] + 1 : 1; } right[n - 1] = 1; for (int i = n - 2; i >= 0; i--) { right[i] = (a[i] < a[i + 1]) ? right[i + 1] + 1 : 1; } int ans = 1; for (int i = 0; i < n; i++) { ans = Math.max(ans, left[i]); if (i > 0) ans = Math.max(ans, left[i - 1] + 1); if (i < n - 1) ans = Math.max(ans, right[i + 1] + 1); if (i > 0 && i < n - 1 && a[i - 1] < a[i + 1] - 1) { ans = Math.max(ans, left[i - 1] + 1 + right[i + 1]); } } System.out.println(ans); } }

这个题有个容易踩的细节：判断条件是a[i - 1] < a[i + 1] - 1，注意这里必须有严格小于，而且差至少是2，因为要留出整数位置给修改后的a[i]。很多人写成了a[i - 1] < a[i + 1]，看着差不多，实际上a[i-1]=3、a[i+1]=4的时候，中间没有整数可以放，合并就是错误的。还有一个问题是数组长度小于等于2时直接返回n，否则后面访问i+1或i-1会越界。这种边界在笔试里特别坑，明明算法对了，因为一个越界RE，整道题白做。

7. 考场实战经验：我这套题刷下来的踩坑清单

7.1 做题顺序建议

网易这批题的难度并不是严格递增的，所以我个人的做题顺序建议是：

1. 先把两道模拟题（闹钟、迷路）秒掉，它们是最稳的送分题，10分钟之内搞定能迅速建立信心。
2. 再做被3整除和安置路灯，这两道题代码量小，但需要一点数学或贪心思考，属于“稍微想一想就能AC”的题。
3. 然后是数对和俄罗斯方块，这两道题考的是思维拐弯，不要一上来就暴力，先想想有没有数学结论。
4. 最后留时间给牛牛的背包和牛牛的数列，这两道题如果思路卡住，先跳过去做别的，回头再战。

这个顺序的核心逻辑是：笔试时间有限，先把确定能拿的分拿满，再啃硬骨头。千万别在第一道模拟题上反复优化输出格式，或者在一道贪心题上死磕证明，导致后面更值钱的题没时间读。

7.2 输入输出上的常见坑

牛客网的笔试环境对代码格式要求很严格：类名必须是Main，不能有package声明，不需要读入文件，所有的输入都从System.in读。很多第一次在牛客上做题的同学会在这些地方栽跟头。另外，多组测试数据的题，比如安置路灯，要用while循环处理T组数据，处理完一组输出一组，不要想当然地只处理一组。

还有一个很实际的经验：对于Java选手，能用BufferedReader就用BufferedReader，Scanner在数据量大的时候会慢不少，但在这套题的规模下Scanner完全够用。真正要关注的是输出的效率，如果用System.out.println高频输出，有概率触发超时，可以换成StringBuilder拼接后统一输出。

7.3 这套题暴露出的通用能力短板

刷完这八道题，我最大的感受是：大厂笔试考的不是你会多少算法，而是你在有限时间内能不能快速识别出题人的真实意图。牛牛的闹钟，包装成一个闹钟场景，本质是时间换算和最大值筛选；俄罗斯方块，看起来要模拟游戏，本质是均摊思维；牛牛的背包问题，披着01背包的外衣，实际上是搜索。这种“脱包装”的能力，需要靠大量刷题和对经典模型的熟悉程度来积累。

如果你现在准备的是2025年的暑期实习，我建议可以把这套题和2018、2020年的网易真题对照着看。你会发现命题风格有一定连贯性，模拟题和数学题是常年保留项目，贪心和DP是拉开差距的关键。把这套题吃透，再去刷其他大厂的真题，你会明显感觉到自己的“脱包装”速度快了不少。