企业官网建设流程全解析

2020年春招那会儿，我面的是映客的算法岗，笔试拿到的正是这份D卷。说实话，映客的算法笔试题在直播行业里算是有分量的，不是随便刷两道LeetCode就能应付的那种，它既要考察经典数据结构和算法的基本功，也会带一点机器学习相关的题目，毕竟是算法岗，不是单纯的后端开发。当时做完这套题，我特意把题型和解题思路记了下来，现在回头看，这套D卷对准备校招算法岗的同学依然有很强的参考价值。

这篇文章我会从试卷的整体结构开始拆，然后逐题讲思路、贴代码、说踩坑点，最后聊一聊笔试现场的时间分配和心态问题。无论你是正在准备春招秋招的应届生，还是想跳槽进直播/泛娱乐行业的算法工程师，这套题都值得认真过一遍。

1. 试卷整体设计与考点分布

1.1 映客算法D卷的题型结构

先说试卷的构成，所有题目都是线上OJ模式，需要在限定时间内完成并提交，编译器支持C++、Java和Python。D卷的整体结构分四部分：单选题、多选题、编程题和一道机器学习简答题。单选题大概10道，每道2分，主要考察数据结构、算法复杂度、操作系统和网络基础；多选题5道左右，难度会明显上一个台阶，经常会出现“以下哪些说法正确”这种需要仔细辨析的题目；编程题有3道，分值占比最大，一道简单、一道中等、一道偏难，这也是决定你能不能进面试的关键；最后那道机器学习简答题更像是附加题，考的是你对基础概念的理解深度。

这种结构其实很典型，算法岗笔试考察的不只是你会不会写代码，还包括基础理论的扎实程度。映客作为直播平台，它的算法团队主要做推荐、内容理解、风控这些方向，所以笔试里出现机器学习的题目一点都不意外，建议准备的时候不要只刷题，基础理论也得过一遍。

1.2 考点覆盖与难度分层

从考点分布来看，D卷有一个很明显的倾向：数据结构基础占比高，字符串处理是重点，动态规划基本必考，机器学习只考最核心的概念。这和LeetCode上那种高频题集是有区别的，它更看重基础和工程实现能力。

具体到难度，我的感受是这样的：单选题和多选题属于送分题和拉分题并存的组合，有些题一眼就能看出答案，有些题则需要你花时间仔细推演；编程题第1道是保底题，基本是链表操作或者字符串处理级别，不能丢分；第2道开始上难度，典型的贪心或DP题，需要你能快速抽象出模型；第3道题会考图论或者高级数据结构，这道题通常只有少数人能完整AC，做不出来也不用太慌，部分正确的得分也能拉开差距。

接下来我按题目类型逐一拆解，重点讲编程题，因为编程题才是笔试的胜负手。

2. 字符串与数据结构类题目解析

2.1 KMP算法与next数组计算

这套卷子单选和多选里都出现了KMP算法，而且不是简单地问“KMP的时间复杂度是多少”，而是直接给你一个模式串，让你算next数组。我印象里题目直接给了p="abacaba"这个模式串，问它的next数组是多少。这种题目只要理解了next数组的定义，就是纯计算题，没有任何难度，但很多人恰恰就是在这里丢分，因为他们只记代码，不理解原理。

首先要明确next数组的定义：next[i]表示模式串p[0...i]这个前缀子串中，最长的相等前缀和后缀的长度。注意，这个长度不能等于整个子串的长度，也就是不能拿自己和自己匹配。有了这个定义，我们直接手动计算。

模式串p = a b a c a b a，长度为7。我们逐个位置计算：

• next[0]：子串是"a"，只有一个字符，没有真前缀和真后缀，所以next[0] = 0。
• next[1]：子串是"ab"，前缀集合{a}，后缀集合{b}，没有交集，所以next[1] = 0。
• next[2]：子串是"aba"，前缀{a, ab}，后缀{a, ba}，最大公共部分是"a"，长度为1，所以next[2] = 1。
• next[3]：子串是"abac"，前缀{a, ab, aba}，后缀{c, ac, bac}，没有交集，所以next[3] = 0。
• next[4]：子串是"abaca"，前缀{a, ab, aba, abac}，后缀{a, ca, aca, baca}，最大公共部分是"a"，长度1，所以next[4] = 1。
• next[5]：子串是"abacab"，前缀{a, ab, aba, abac, abaca}，后缀{b, ab, cab, acab, bacab}，最大公共部分是"ab"，长度2，所以next[5] = 2。
• next[6]：子串是"abacaba"，前缀{a, ab, aba, abac, abaca, abacab}，后缀{a, ba, aba, caba, acaba, bacaba}，最大公共部分是"aba"，长度3，所以next[6] = 3。

所以这个模式串的next数组是[0, 0, 1, 0, 1, 2, 3]。如果你用的是某些教材或算法库中从1开始计数的版本，结果会整体偏移一位，题目里如果没有明确说明，通常默认是从0开始计数的，这个要注意。

这里我分享一个我的判断技巧：你算出来的数组最后一位是什么，可以用来反过来验证自己有没有算错。像这个题最后一位是3，说明整个字符串的最长公共前后缀是"aba"，你回看字符串最后三个字符确实是"aba"，这个验证过程很快，能帮你发现低级错误。

2.2 编程题：字符串去重与排序

D卷的第一道编程题，我记得很清楚，是“给定一个字符串，去除其中重复的字符，并按照字符的ASCII码从小到大排序输出”。这题不难，但它考察的是你对容器和排序的熟练度。第一次做这类题的同学容易犯一个错误：用两层循环暴力去重，时间复杂度 O(n^2)，字符串长一点就会超时。

其实这题有个很简单的做法：用一个bool数组或者set去记录已经出现过的字符，然后遍历一次字符串把所有出现过的字符收集起来，最后排序输出。如果进一步优化，因为英文字母的ASCII码范围是有限的，可以直接开一个大小为128的布尔数组，每次遇到字符就把对应位置置为true，最后遍历这个数组输出即可。这样时间复杂度是 O(n)，空间复杂度是 O(1)，完美。

#include <bits/stdc++.h> using namespace std; int main() { string s; cin >> s; bool vis[128] = {false}; for (char c : s) { vis[c] = true; } for (int i = 0; i < 128; i++) { if (vis[i]) cout << (char)i; } cout << endl; return 0; }

这题我重点提醒三件事。第一，看清题目要求，是去重后保留原始顺序还是排序输出，这题要求的是排序，如果你保留了原始顺序就错了。第二，如果字符串里可能包含大写字母和小写字母，ASCII码的排序结果是A-Z在a-z前面，题目如果没有特别说明大小写不敏感，那就按ASCII码来，不要画蛇添足做大小写转换。第三，输入是否可能包含空格？如果可能，用getline而不是cin，这道题没给这个坑，但类似的题目经常有。

3. 排序算法与查找算法专题

3.1 手写快速排序的边界问题

D卷的单选题里出现了排序算法的比较，多选里也有“下列哪些排序算法是稳定的”这种题。这种题属于经典八股，但编程题里也暗含排序的考察，而且是在第2道编程题里用到了排序的关键思想。但在这之前，先把这些基础考点说透。

快速排序的考点通常集中在：时间复杂度（平均O(n log n)，最坏O(n^2)）、是否稳定（不稳定）、以及手写实现的边界处理。笔试时如果让你手写快排，一定要注意你的实现里 ```left和right` 指针的移动顺序，以及递归终止条件。

我在这里贴一个我常用的、不容易写错的快排模板：

int partition(vector<int>& nums, int l, int r) { int pivot = nums[l]; while (l < r) { while (l < r && nums[r] >= pivot) r--; nums[l] = nums[r]; while (l < r && nums[l] <= pivot) l++; nums[r] = nums[l]; } nums[l] = pivot; return l; } void quickSort(vector<int>& nums, int l, int r) { if (l >= r) return; int pos = partition(nums, l, r); quickSort(nums, l, pos - 1); quickSort(nums, pos + 1, r); }

这个模板的核心思想是：先取最左边的元素作为基准值，然后从右往左找比基准值小的元素，把它填到左边的坑里；再从左往右找比基准值大的元素，把它填到右边的坑里。这样左右交替填坑，最后把基准值放回正确位置。整个过程只需要 O(1) 的额外空间。

踩坑提醒：一定是先从右往左找，再从左往右找，顺序不能反。因为基准值取的是最左边的元素，如果先从左往右找，会破坏初始的“坑位”逻辑，最终结果仍然是正确的，但某些极端情况下下标会越界。笔试的时候如果时间紧，用这个模板可以直接默写，不容易出错。

3.2 堆排序与TopK问题的实战思路

D卷编程题第2题，我记得是“给定一个无序数组，找出其中第K大的元素”。这题看着简单，但它有多种解法，每种解法的优劣也反映了你对算法理解的深度。

最简单的做法：直接排序然后取下标为n - k的元素，时间复杂度 O(n log n)。在笔试中，如果数组长度不超过10的5次方，这个做法是可以通过的，完全没问题。但如果你追求更优解法，可以用快速选择算法，基于快排的partition思想，平均时间复杂度降为 O(n)；或者利用容量为K的最小堆，时间复杂度 O(n log K)，空间复杂度 O(K)。

我当时用的是最小堆的做法。遍历数组时，维护一个大小为K的最小堆，每来一个新元素，如果堆的大小小于K就直接入堆，否则如果新元素大于堆顶，就弹出堆顶并把新元素入堆。遍历结束后，堆顶就是第K大的元素。用C++的priority_queue<int, vector<int>, greater<int>>可以直接实现。

#include <bits/stdc++.h> using namespace std; int findKthLargest(vector<int>& nums, int k) { priority_queue<int, vector<int>, greater<int>> pq; for (int x : nums) { if (pq.size() < k) pq.push(x); else if (x > pq.top()) { pq.pop(); pq.push(x); } } return pq.top(); } int main() { int n, k; cin >> n >> k; vector<int> nums(n); for (int i = 0; i < n; i++) cin >> nums[i]; cout << findKthLargest(nums, k) << endl; return 0; }

这道题我强烈建议你把三种解法都写一遍，因为面试环节很可能会追问：“如果数组很大，大到不能全部加载到内存怎么办？”这时候你可以回答使用堆，因为堆的空间复杂度只有O(K)，可以配合外部排序或者流式处理。这就是典型的笔试为面试做的铺垫，你在笔试时用最优解，面试时就能顺着往下说。

顺带说一句，堆排序本身也是常考的排序算法。它的时间复杂度是O(n log n)，而且不稳定。它和快速排序的差别在于，堆排序最坏情况下依然是O(n log n)，而快排最坏会退化到O(n^2)，所以某些对稳定性没有要求但要求最坏情况可控的场景，堆排序反而是更好的选择。

4. 图论与贪心算法实战

4.1 单源最短路径：Dijkstra算法与堆优化

D卷第3道编程题，我印象里是图论相关的，给了一个带权无向图，要求计算从源点到所有点的最短路径。这题考察的是Dijkstra算法，而且题目里图的规模比较大，用朴素的O(V^2)写法会超时，所以必须用优先队列优化，也就是堆优化的Dijkstra，时间复杂度 O(E log V)。

Dijkstra算法的核心思想是贪心：每次从未确定最短路的顶点中，取出距离源点最近的那个顶点，用它的出边去松弛其他顶点。这个“取出最近顶点”的操作如果用普通数组遍历，每次要O(V)，整体就是O(V^2)；如果用小根堆来维护，每次取出堆顶是O(log V)，整体就是O(E log V)，在稀疏图上效果非常明显。

#include <bits/stdc++.h> using namespace std; const int INF = 0x3f3f3f3f; vector<pair<int, int>> adj[100005]; int dist[100005]; void dijkstra(int s, int n) { fill(dist, dist + n + 1, INF); dist[s] = 0; priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq; pq.push({0, s}); while (!pq.empty()) { auto [d, u] = pq.top(); pq.pop(); if (d > dist[u]) continue; for (auto [v, w] : adj[u]) { if (dist[u] + w < dist[v]) { dist[v] = dist[u] + w; pq.push({dist[v], v}); } } } } int main() { int n, m, s; cin >> n >> m >> s; for (int i = 0; i < m; i++) { int u, v, w; cin >> u >> v >> w; adj[u].push_back({v, w}); adj[v].push_back({u, w}); } dijkstra(s, n); for (int i = 1; i <= n; i++) { if (dist[i] == INF) cout << "INF "; else cout << dist[i] << " "; } cout << endl; return 0; }

这里有两个关键的细节必须注意。第一，if (d > dist[u]) continue这句不能省，因为同一个顶点可能被多次入堆，当它被取出来时，如果当前记录的距离已经比堆里保存的距离小，说明这是一条过期的松弛记录，直接跳过，否则会多做很多无效操作，甚至可能导致死循环。第二，边的存储用的是pair<int, int>，默认排序是先按第一个元素排，所以要把距离放在first，顶点编号放在second，这样堆顶就是距离最小的顶点。

负权边的图是不能用Dijkstra的，这一点多选题里也会考。如果图中存在负权边，但不存在负权环，可以用SPFA；如果存在负权环，最短路径问题本身就是无解的。这种知识边界要理清楚，面试官很爱在这个地方做文章。

4.2 最小生成树与并查集的应用

D卷的多选题里有一道“下列关于最小生成树的说法正确的是”的题目，选项中涉及Prim算法和Kruskal算法的比较。这题不难，但需要你记住：Prim算法适合稠密图，时间复杂度O(V^2)，用堆优化可以到O(E log V)；Kruskal算法适合稀疏图，时间复杂度O(E log E)，它的核心数据结构是并查集。

并查集在这里不只是为了过笔试，它本身就是算法岗面试的高频考点。我在准备映客D卷的时候，把并查集的路径压缩和按秩合并写成了一个模板，每次遇到图论题直接复用：

int fa[100005]; int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); } void unite(int x, int y) { x = find(x); y = find(y); if (x != y) fa[x] = y; }

上面这个find函数里用了路径压缩，也就是在递归查找的过程中，直接把节点的父节点指向根节点，这样下次查询就是O(1)级别。如果加上按秩合并，也就是让深度小的树往深度大的树上合，可以进一步保证树的深度不超过O(log n)，这样整体的时间复杂度就是反阿克曼函数级别的，几乎可以认为是常数时间。

最小生成树的思想在直播业务里也有应用场景，比如视频分发网络中的节点组网优化、多机房之间的专线成本预估，抽象出来都是在一个加权无向图里找最小成本的连通方案。如果你能在笔试的编程题里主动提到这个业务关联，面试官会觉得你不只是会刷题，而是真的在思考怎么把算法落地到业务中。

4.3 贪心算法：区间调度类问题

D卷没有单独出一道贪心题，但在某道多选题里考察了一个“给定一系列区间，选出尽可能多的互不重叠的区间”的问题，这其实是经典的贪心算法典型题。做法也简单：把所有区间按右端点排序，然后从左到右遍历，能选就选。

这个思路说出来很简单，但很多人不知道为什么按右端点排序是正确的最优解。我当时的理解方式是这样的：如果按右端点排序，每次选择的区间结束得越早，留给后面区间的空间就越大，因此选择的区间数量就可能越多。如果按左端点排序或者按区间长度排序，都可能导致一个覆盖范围很大的区间被选中，从而挤掉后面多个小区间，这不是我们希望看到的。

struct Interval { int l, r; bool operator<(const Interval& other) const { return r < other.r; } }; int maxNonOverlapping(vector<Interval>& intervals) { sort(intervals.begin(), intervals.end()); int cnt = 0, lastEnd = -1; for (auto& it : intervals) { if (it.l >= lastEnd) { cnt++; lastEnd = it.r; } } return cnt; }

我建议在做这类题目的时候，先在草稿纸上画一条时间线，把区间画上去，然后手动模拟一遍贪心选择的过程。这个过程能帮你快速理解贪心策略为什么正确，也能帮你在面试的时候给面试官讲明白你的思路。面试时，光说“这题用贪心”是不够的，还要能论证“为什么贪心是对的”。

5. 动态规划专项突破

5.1 从记忆化搜索到递推DP

动态规划是算法岗笔试的绝对主力，映客D卷的编程题第2题或者第3题的位置上出现过一道典型的DP题，我印象中是一道最长上升子序列（LIS）的变种题。

LIS最基础的做法是O(n^2)的动态规划：定义dp[i]表示以第i个元素结尾的最长上升子序列长度，状态转移方程是：dp[i] = max(dp[j] + 1)，其中j < i且nums[j] < nums[i]。这个思路很好理解，而且是很多复杂DP问题的基础，一定要能默写出来。

不过，如果题目把数据范围加大到n是10的5次方，O(n^2)的DP就超时了。这时候需要用贪心+二分的优化，维护一个数组d，d[i]表示长度为i的上升子序列的最小末尾元素值。遍历每个元素时，在d数组中二分查找第一个大于等于当前元素的位置，并更新它。

int lengthOfLIS(vector<int>& nums) { vector<int> d; for (int x : nums) { auto it = lower_bound(d.begin(), d.end(), x); if (it == d.end()) d.push_back(x); else *it = x; } return (int)d.size(); }

这个优化版本就是经典的“耐心排序”思想，理解起来稍微有些抽象。我自己的理解方式是把d[i]想成“长度为i的子序列，结尾能有多小”。比如数组[2, 1, 3]，遍历到2的时候，d变成[2]；遍历到1的时候，lower_bound找到第一个大于等于1的位置是开头，把2替换成1，d变成[1]。这并不代表子序列的长度变短了，只是说明“长度为1的子序列，最小可以以1结尾”，这个信息在后续扩展时非常有用。遍历到3的时候，3比当前d中所有元素都大，所以扩展，d变成[1, 3]，长度为2。

笔试的时候，如果你对二分版本没把握，可以先用O(n^2)版本写一遍，确保能过基础测试用例，然后如果时间充裕再去优化。很多人的策略是直接用二分版本，结果边界条件写错，反而丢了全部分数。稳扎稳打，先把基础分拿到，再考虑拔高。

5.2 背包问题的状态设计思路

背包问题是DP里最常考的一大类问题，映客D卷虽然没有直接考裸的背包题，但它的DP题里隐含了背包的思想：给定若干物品，每个物品有价值和一个限制条件，问在限制范围内如何选择使总价值最大。这是典型的0-1背包。

0-1背包的状态转移方程你一定要形成肌肉记忆：dp[j] = max(dp[j], dp[j - weight[i]] + value[i])，遍历j的时候必须从大到小。为什么要从大到小？因为0-1背包要求每个物品只能选一次，如果从小到大遍历j，那么dp[j - weight[i]]可能已经在当前物品的循环中被更新过了，这就相当于同一个物品被选了多次，变成了完全背包的问题。

vector<int> dp(capacity + 1, 0); for (int i = 0; i < n; i++) { for (int j = capacity; j >= weight[i]; j--) { dp[j] = max(dp[j], dp[j - weight[i]] + value[i]); } }

如果同样的问题改成“每个物品可以选无限次”，那就是完全背包，遍历j的时候改成从小到大即可。这两种背包的区别就是一个循环顺序的差别，但含义完全不同，笔试的时候一定要看清题目说的是“每个物品只有一个”还是“每个物品有无限多个”。

D卷的多选题里出现过“以下哪些属于动态规划的应用场景”的选项，其中包含“最长公共子序列”“背包问题”“Dijkstra算法”等。这道题就是在考察你对算法思想本质的理解，Dijkstra看起来像DP，但它本质上是贪心，不是DP，这个区分一定要能说清楚。

6. 机器学习基础题与业务结合

6.1 过拟合的识别与处理方法

D卷的最后有一道简答题，内容是“在推荐系统的CTR预估模型中，训练集AUC很高但测试集AUC很低，分析可能的原因并给出解决方案”。这题本质是在考过拟合，但直接问过拟合太泛，结合CTR预估这个业务场景之后，难度就上来了。

我当时从三个层面回答了这个问题。首先是数据层面：训练集和测试集分布不一致，比如训练样本大多来自某几个特定时间段或特定用户群，而测试集覆盖了全量用户；解决方案是做样本重采样、按时间划分训练集验证集、做更精细的特征分桶。其次是模型层面：模型过于复杂，特征维度高、树模型深度过大，或者深度网络层数过多，导致把训练集的噪声也学进去了；解决方案是加正则化项、降低模型复杂度、增加Dropout比例、提前停止训练。最后是特征工程层面：使用了大量高基类别特征但又没有做充分的平滑处理，导致模型记住了训练集中的特例，而不是学到泛化规律；解决方案是特征哈希、embedding降维、或者对高基特征做目标编码的时候要加平滑项。

这一题的回答质量，很大程度上能看出你是否真正做过机器学习项目，而不只是背过概念。如果你是校招生，没有太多实习经验，也一定要把这个问题的逻辑链条想清楚：数据、模型、特征三者之间的关系，以及如何用验证集来判断模型到底是不是过拟合。

6.2 常见损失函数与评估指标选择题

D卷的多选题里还考察了损失函数和评估指标之间的对应关系。这类题目属于送分题，但需要你记忆准确。我把常见的对应关系整理一下：

• 二分类问题常用：交叉熵损失（配合sigmoid或softmax）、hinge损失（配合SVM）
• 回归问题常用：均方误差MSE、平均绝对误差MAE、Huber Loss
• 评估指标：准确率Accuracy、精确率Precision、召回率Recall、F1值、AUC

这里面最容易混淆的是Precision和Recall。一句话帮助记忆：Precision是“预测为正的里面有多少是真正的正例”，Recall是“真实为正的里面有多少被预测出来了”。在推荐系统和风控场景中，这两个指标往往此消彼长，需要通过调整阈值来平衡。

AUC这个指标在CTR预估里是必考的，它的含义是“随机从正样本中取一个，随机从负样本中取一个，正样本得分大于负样本得分的概率”。AUC对样本不均衡不敏感，所以在点击率预估这种正负样本比例悬殊的场景里，AUC比Accuracy更可靠。这个点我在回答简答题的时候也提到了，作为评估指标的补充说明，会显得你的答案更完整。

7. 笔试实战避坑与时间分配

7.1 编程题常见的隐藏坑

讲完了具体的题目，再来聊聊笔试现场的实战问题。映客用的在线OJ系统，对代码格式、输入输出、内存限制都有严格的要求，我总结了自己在笔试里踩过的几个坑，也希望你们能避开。

第一个坑是输入输出的格式问题。千万不要在输出里添加多余的提示信息，比如“请输入数组长度”这种话，OJ系统是全自动判题的，它只比对标准输出，多了任何字符都会被判错。第二个坑是数组越界，尤其是C++的数组大小开小了，OJ系统会直接报Runtime Error。我的习惯是统一把数组大小开到题目上限加5到10，比如数据范围是10的5次方，我就开100005，宁可浪费一点内存，也不要越界。第三个坑是数据量大的时候必须用scanf/printf或者关闭C++的输入输出同步，ios::sync_with_stdio(false)和cin.tie(nullptr)这两行一定要写，否则cin读入10的6次方级别数据会明显变慢，超时就很冤枉了。

再说一个容易被忽略的：题目给的变量名可能和常规习惯不一样，比如“给定n个整数，其中n表示数字个数”和“给定一个字符串s，其中s的长度为n”这两种描述方式可能会出现在同一道题里，读题的时候一定要看清每道题里每个字母的含义，不要死板地认为n一定表示数组长度。

7.2 时间分配与答题顺序策略

D卷的答题时间是90分钟，题量大概在18题左右，其中编程题占了大头。这个时间是很紧张的，我当时的时间分配策略是这样的：单选和多选一共控制在25分钟以内，不会的题先蒙一个答案并标记，不在一道题上死磕；3道编程题，第1道简单题控制在10分钟以内，第2道中等题控制在20分钟以内，第3道难题预留25分钟，最后留10分钟检查代码和做没做完的标记题。

这个策略的核心思路是：确保简单题和中档题不丢分，然后再去冲击难题。很多同学在难题上死磕了40分钟，结果前面的简单选择题没时间检查，丢了基础分，非常可惜。编程题如果实在没有思路，也要把暴力解法写出来，因为OJ系统的判题规则往往是部分正确的，能过几个测试用例就能拿几分。比如第3道图论题，如果不会Dijkstra，至少可以写一个Floyd算法的O(n^3)版本，在小数据量的测试用例上也能拿一些分数。

笔试结束后，强烈建议你立刻把自己写过的代码复制保存下来。一方面可以复盘自己的思路，另一方面，如果后续面试官问“你笔试的时候第三题是怎么做的”，你能够准确地说出你的实现细节。我自己的习惯是，每做完一道编程题，就把代码以题目的关键字命名存到本地目录里，比如dijkstra_heap.cpp、kth_largest.cpp，这样后续复盘时效率极高。

8. 算法题的扩展与面试追问准备

8.1 从D卷考点延伸到面试高频题

笔试只是第一关，通过笔试之后，面试环节还会围绕笔试题进行深度追问。根据我的经验，映客的面试官会问你“这道题还有没有其他解法”或者“你的解法在什么场景下会退化”，这些都是从D卷的考点延伸出来的。所以你在准备笔试的时候，就要带着面试的视角去思考每一道题。

举个例子，D卷考了Dijkstra算法，面试官追问的方向大概率是：如果图中存在负权边怎么办？如果图是稀疏图，用堆优化还是朴素写法？如果要求多源最短路径，应该用什么算法？你可能还需要手写一遍SPFA或者Floyd。同理，D卷考了TopK问题，面试官就会追问海量数据场景，比如1亿个整数中找最大的100个，内存只有10MB，这时候你需要回答分治+堆，或者基于哈希分桶的外部排序方案。

我强烈建议你准备一个“一题多解”的笔记本，每做完一道笔试题，就在下面补充至少两种解法，并分析它们的时空复杂度。这个习惯会在面试时给你带来巨大的回报，因为面试官最烦听到“这题我只会一种解法”这种回答。

8.2 直播业务场景中算法岗的真实工作

最后聊一点软性的内容。映客是做直播和社交的，算法岗进去之后主要会接触三类业务：推荐系统（直播间推荐、用户关注流排序）、内容理解（图像/音频的分类与审核）、以及风控（反垃圾、反作弊）。D卷里的机器学习简答题和这些业务是强相关的，如果你在笔试阶段就展现出对业务场景的理解，会让面试官对你的评价上一个台阶。

举个例子，直播间的推荐可以抽象成一个典型的召回+排序两阶段问题。召回阶段用协同过滤、聚类、向量召回等方法从海量直播间中选出一批候选；排序阶段用CTR预估模型（LR、GBDT、DeepFM等）对候选直播间打分。这个过程中既要处理用户行为序列，又要考虑直播间的实时状态（在线人数、热度趋势等），比传统的商品推荐要复杂得多。准备校招的同学，可以提前去了解一下这一套推荐系统的经典架构，不需要太深，但至少要知道每个模块是干什么的，以及算法岗在其中的位置。

我个人在实际准备这套D卷的过程中，最大的体会是：算法笔试表面上考的是代码能力和知识记忆，实际上考的是你在有限时间内判断“该拿什么分、该放弃什么题”的决策能力。映客D卷的题目难度分布很科学，它不会让所有人都做不出来，但也不会让所有人都拿满分，最终筛选出来的是那些基本功扎实、临场心态稳定、能够合理分配精力的候选人。

如果你正在准备算法岗的春招或秋招，我建议你把这份D卷当成一次全真模拟，先自己掐时间做一遍，再对照文章里的思路复盘。最后再分享一个小技巧：每次模拟完笔试，把错题和超时的题目整理到一个“错题本”里，标注错误原因和正确思路，考前只需翻这个本子，效率比刷十套新题都高。