数位动态规划实战：高效求解区间内不含特定二进制模式的数字个数

1. 项目概述：从一道华为OD机试题说起

最近在准备华为OD机试，或者关注算法题的朋友，可能都刷到过这道题：“在给定区间内不含101的数”。题目本身描述很简洁，但背后涉及到的二进制数位处理、区间计数技巧，以及如何高效地在不同编程语言中实现，都是非常值得深挖的实战考点。这道题不仅是华为OD机试的常客，其变体也出现在吉林大学、中科大等高校的夏令营机试中，足以见得其作为考察候选人基础算法和思维严谨性的“试金石”地位。

简单来说，题目要求我们：给定一个整数区间[L, R]，我们需要统计在这个区间内，所有在二进制表示下不包含连续子串“101”的正整数个数。例如，数字5的二进制是101，它就包含“101”，因此需要被排除；而数字6的二进制是110，它不包含连续的“101”，所以是有效的。这个问题初看可能觉得直接遍历区间、逐个数字转换二进制判断就行，但一旦区间范围很大（比如L=1, R=10^9），这种暴力解法的时间复杂度是O(N * logN)，必然会超时。因此，核心挑战在于如何设计一个亚线性甚至对数级时间复杂度的算法。

本文将从一个资深开发者的视角，彻底拆解这道题。我会先带大家理解问题本质，然后深入讲解一种高效的通解思路——数位动态规划（Digit DP），并分别用C++、Java、JavaScript和Python四种语言实现。更重要的是，我会分享在实现过程中，不同语言特性带来的编码差异、常见的“坑点”以及调试技巧。无论你是正在备战华为OD，还是想巩固数位DP这一重要算法思想，这篇文章都将提供一份可直接“抄作业”的详细指南。

2. 问题核心与高效算法选型

为什么暴力解法不行？我们简单算一笔账。假设区间是[1, 10^9]，遍历需要10^9次循环。每次循环需要将数字转为二进制字符串（或进行位运算判断），转换复杂度约为O(logN)，对于10^9这个量级，logN约等于30。那么总操作次数粗略为3 * 10^10量级，这在任何机试环境（通常限制1~2秒）下都是不可接受的。因此，我们必须寻找更聪明的方法。

这道题的本质是一个数位统计问题。我们不再关心每个具体的数，而是关心在某个数位范围内，满足特定条件（二进制不含“101”）的数的“形态”有多少种。这立刻让人联想到数位动态规划（Digit DP）。数位DP是解决此类“区间内满足某条件的数字个数”问题的标准且强大的武器。它的核心思想是将数字看作一个数字串（这里是二进制串），从高位到低位进行决策，利用动态规划记录在某个位置、处于某种状态下的方案数，从而避免了对每个数字的独立检查。

具体到“不含101”这个条件，我们需要在状态设计中捕捉到“当前已匹配到了‘101’模式中的哪一位”。我们可以定义一个状态state：

• state = 0: 当前末尾还没有形成“101”的前缀，或者上一个位不是‘1’。
• state = 1: 当前末尾是‘1’，即匹配到了“101”的第一个字符‘1’。
• state = 2: 当前末尾是“10”，即匹配到了“101”的前两个字符“10”。 当我们在某一位填入‘1’，且当前状态为2（即前两位是“10”）时，就形成了完整的“101”，此时这个分支就应该被禁止（方案数为0）。

有了这个状态定义，我们就可以构建DP记忆化搜索函数：dfs(pos, state, isLimit, isNum)。

• pos: 当前正在处理二进制串的第几位（从最高位向最低位处理）。
• state: 上述定义的匹配状态（0, 1, 2）。
• isLimit: 布尔值，表示当前位是否受到区间上界的限制。例如，区间上界R的二进制是1101，当我们决策的高位已经和R的高位完全相同时，下一位的选择就不能超过R对应位置的值（0或1），否则就会超过R。
• isNum: 布尔值，表示当前是否已经开始构造数字（即是否跳过了前导零）。这对于处理数字0和保证我们统计的是正数很重要。

函数返回从pos位开始，在给定state和限制条件下，能构造出的合法数字个数。通过递归搜索所有可能的位置和状态，并利用记忆化避免重复计算，我们可以将时间复杂度降至O(logR * 3 * 2 * 2)，对于R最大为10^9（二进制位约30位），这个计算量微乎其微。

注意：这里有一个初学者极易混淆的点。数位DP的“记忆化”必须配合isLimit和isNum这两个参数。只有当!isLimit && isNum时，当前(pos, state)的结果才可以被缓存（memoize）。因为isLimit=true意味着后续选择受限于上界R，这个结果是针对当前这条特定路径的，不能被其他路径复用；isNum=false意味着还在处理前导零，状态state可能没有意义（因为前导零不参与“101”模式的匹配）。忽略这个条件会导致错误计数。

3. 核心算法实现与四语言代码解析

理解了算法框架，接下来我们看具体实现。我将以C++、Java、JavaScript和Python四种语言分别实现，并重点分析每种语言在实现数位DP时的细微差别和最佳实践。首先，我们定义一个公共的解题函数countValidNumbers(L, R)，它返回区间[L, R]内不含101的数的个数。我们可以利用数位DP计算[0, X]内合法数的个数f(X)，那么答案就是f(R) - f(L-1)。

3.1 C++ 实现详解

C++以其高效的执行速度和丰富的标准库，常作为算法竞赛的首选。实现数位DP时，我们通常使用递归+记忆化。

#include <bits/stdc++.h> using namespace std; class Solution { private: int memo[32][3]; // 记忆化数组，pos范围[0,31]，state范围[0,2] vector<int> digits; // 存储数字X的二进制位（从高位到低位） // DFS函数：构造从pos位开始，当前状态为state，是否受上限限制isLimit，是否已开始构造数字isNum的合法方案数 int dfs(int pos, int state, bool isLimit, bool isNum) { if (pos == digits.size()) { // 递归终点：如果已经构造了一个数字（isNum为真），则算一种方案（空数字0不算） return isNum ? 1 : 0; } // 记忆化：只有在无限制且已开始构造数字时，结果才是通用的，可以缓存 if (!isLimit && isNum && memo[pos][state] != -1) { return memo[pos][state]; } int res = 0; // 计算当前位可以填的上界 int up = isLimit ? digits[pos] : 1; // 二进制位只能是0或1 // 尝试填入0或1 for (int d = 0; d <= up; d++) { int nextState = state; if (isNum || d == 1) { // 只有开始构造数字或当前位填1时，才更新状态 if (state == 0) { nextState = (d == 1) ? 1 : 0; } else if (state == 1) { nextState = (d == 0) ? 2 : 1; // 前一位是1，当前填0则状态变为2（"10"） } else { // state == 2 if (d == 1) { // 形成“101”，非法分支，跳过 continue; } else { nextState = 0; // 填0则破坏“10”序列，状态重置 } } } else { // 还在前导零阶段，状态保持为0 nextState = 0; } // 递归到下一位，更新限制条件：当前位若达到上限且d等于上限值，则下一位继续受限 bool nextLimit = isLimit && (d == up); // 更新是否已开始构造数字：如果之前已开始，或者当前位填了1（跳过了前导零），则isNum为真 bool nextIsNum = isNum || (d == 1); res += dfs(pos + 1, nextState, nextLimit, nextIsNum); } // 缓存结果 if (!isLimit && isNum) { memo[pos][state] = res; } return res; } // 辅助函数：计算[0, X]范围内合法数的个数 int f(int X) { if (X < 0) return 0; memset(memo, -1, sizeof(memo)); // 初始化记忆化数组为-1 digits.clear(); // 将X转换为二进制位列表，高位在前 while (X) { digits.push_back(X % 2); X /= 2; } reverse(digits.begin(), digits.end()); // 反转得到从高位到低位的顺序 if (digits.empty()) digits.push_back(0); // 处理X为0的情况 // 从最高位开始DFS，初始状态：未开始构造数字（isNum=false），状态为0，受上限限制 return dfs(0, 0, true, false); } public: int countValidNumbers(int L, int R) { // 题目要求统计正整数，所以L至少为1。我们计算[0,R] - [0,L-1] return f(R) - f(L - 1); } }; // 示例用法 int main() { Solution sol; cout << sol.countValidNumbers(1, 10) << endl; // 应输出区间[1,10]内不含101的数的个数 return 0; }

C++实现要点与避坑指南：

1. 记忆化数组初始化：memo数组必须用-1初始化，因为方案数可能为0，用0初始化会与“未计算”状态冲突。使用memset(memo, -1, sizeof(memo))是最佳实践。
2. 二进制转换：注意我们通过循环取余和除法得到的是从低位到高位的顺序，必须用reverse反转，以满足DFS从高位开始处理的需求。
3. 状态转移逻辑：这是最容易出错的部分。务必注意，只有在isNum为真（已经开始构造数字）或者当前位d==1（即用‘1’打破了前导零）时，我们才需要根据state和d更新nextState。否则，说明我们还在前导零阶段，nextState应保持为0，不参与“101”模式的匹配。
4. 递归终点：当pos == digits.size()时，我们成功走到了最低位之后，此时如果isNum为真，说明我们构造了一个有效的数字（至少有一个非前导零的位），返回1；否则，说明我们构造的是全零（即数字0），根据题目要求（通常统计正整数），返回0。

3.2 Java 实现详解

Java的实现与C++类似，但由于Java没有全局数组的便捷初始化，且使用类封装，代码结构会稍有不同。

import java.util.*; public class Solution { private int[][] memo; private List<Integer> digits; private int dfs(int pos, int state, boolean isLimit, boolean isNum) { if (pos == digits.size()) { return isNum ? 1 : 0; } if (!isLimit && isNum && memo[pos][state] != -1) { return memo[pos][state]; } int res = 0; int up = isLimit ? digits.get(pos) : 1; for (int d = 0; d <= up; d++) { int nextState = state; if (isNum || d == 1) { if (state == 0) { nextState = (d == 1) ? 1 : 0; } else if (state == 1) { nextState = (d == 0) ? 2 : 1; } else { // state == 2 if (d == 1) { continue; // 形成101，跳过 } else { nextState = 0; } } } else { nextState = 0; } boolean nextLimit = isLimit && (d == up); boolean nextIsNum = isNum || (d == 1); res += dfs(pos + 1, nextState, nextLimit, nextIsNum); } if (!isLimit && isNum) { memo[pos][state] = res; } return res; } private int f(int X) { if (X < 0) return 0; // 初始化记忆化数组，二进制位数最多32位（int范围） memo = new int[32][3]; for (int i = 0; i < 32; i++) { Arrays.fill(memo[i], -1); } digits = new ArrayList<>(); // 将X转为二进制列表 int temp = X; if (temp == 0) { digits.add(0); } else { while (temp > 0) { digits.add(temp % 2); temp /= 2; } Collections.reverse(digits); } return dfs(0, 0, true, false); } public int countValidNumbers(int L, int R) { return f(R) - f(L - 1); } public static void main(String[] args) { Solution sol = new Solution(); System.out.println(sol.countValidNumbers(1, 10)); // 测试 } }

Java实现差异与注意点：

1. 数组初始化：Java中二维数组memo需要手动循环初始化，使用Arrays.fill(memo[i], -1)。注意memo的大小，对于int范围的数，二进制位最多32位（符号位不算，但我们按无符号处理31位足够，为保险取32）。
2. 集合的使用：使用ArrayList<Integer>来存储二进制位。转换后需要Collections.reverse(digits)进行反转。
3. 递归函数设计：在Java中，递归函数通常定义为类的私有方法。由于需要访问和修改memo和digits，它们也被设计为成员变量。每次调用f(X)前，需要重新初始化memo和digits。
4. 整数处理：注意处理X=0的特殊情况，直接向列表中添加一个0。

3.3 JavaScript 实现详解

JavaScript在浏览器和Node.js环境中运行，其函数式特性和闭包在实现数位DP时非常灵活。

/** * 统计区间[L, R]内二进制表示不含“101”的正整数个数 * @param {number} L - 区间左端点 * @param {number} R - 区间右端点 * @return {number} */ var countValidNumbers = function(L, R) { // 辅助函数：计算[0, X]范围内的合法数个数 const f = (X) => { if (X < 0) return 0; // 将X转换为二进制数组（字符串形式便于处理，但这里我们用数组存数字） const binaryStr = X.toString(2); const digits = binaryStr.split('').map(Number); // 例如：5 -> '101' -> [1,0,1] // 记忆化缓存，使用Map嵌套Map，键为(pos_state_isLimit_isNum)组合的字符串 // 注意：由于isLimit和isNum是布尔值，且只有特定组合可缓存，这里我们换种方式 // 更清晰的做法：使用三维数组 memo[pos][state][isLimit?][isNum?]，但维度太多。 // 标准做法：只缓存 !isLimit && isNum 的情况，用一个二维数组即可。 const memo = new Array(32); for (let i = 0; i < 32; i++) { memo[i] = new Array(3).fill(-1); } const dfs = (pos, state, isLimit, isNum) => { if (pos === digits.length) { return isNum ? 1 : 0; } // 只缓存无限制且已开始构造数字的状态 if (!isLimit && isNum && memo[pos][state] !== -1) { return memo[pos][state]; } let res = 0; const up = isLimit ? digits[pos] : 1; for (let d = 0; d <= up; d++) { let nextState = state; if (isNum || d === 1) { if (state === 0) { nextState = (d === 1) ? 1 : 0; } else if (state === 1) { nextState = (d === 0) ? 2 : 1; } else { // state === 2 if (d === 1) { continue; // 形成101，非法 } else { nextState = 0; } } } else { nextState = 0; } const nextLimit = isLimit && (d === up); const nextIsNum = isNum || (d === 1); res += dfs(pos + 1, nextState, nextLimit, nextIsNum); } if (!isLimit && isNum) { memo[pos][state] = res; } return res; }; return dfs(0, 0, true, false); }; return f(R) - f(L - 1); }; // 测试 console.log(countValidNumbers(1, 10)); // 输出结果

JavaScript实现特点与技巧：

1. 二进制转换：利用Number.prototype.toString(2)可以非常方便地将数字转为二进制字符串，再通过split('').map(Number)转为数字数组。这比手动循环除2取余更简洁。
2. 记忆化存储：JS中可以用二维数组memo[pos][state]，但需要初始化填充-1。注意数组大小，pos最大为二进制位数，对于Number安全整数范围（2^53），位数也不会超过64，这里预分配32或64均可。
3. 闭包的使用：dfs函数定义在f函数内部，可以自然地访问digits和memo，形成了闭包，结构清晰。
4. 大数注意事项：JavaScript的Number是双精度浮点数，但整数范围足够大（2^53）。不过，在涉及极大数的位运算时（此题未涉及），可能需要使用BigInt。本题在华为OD机试范围内，使用Number足够。

3.4 Python 实现详解

Python以其简洁的语法和强大的内置函数，在实现数位DP时往往代码量最少，可读性很高。

from functools import lru_cache class Solution: def countValidNumbers(self, L: int, R: int) -> int: def f(X: int) -> int: if X < 0: return 0 # 将X转换为二进制字符串，然后转为整数列表 s = bin(X)[2:] # bin(5) -> '0b101'，取[2:] digits = list(map(int, s)) # 转为[1,0,1] @lru_cache(maxsize=None) def dfs(pos: int, state: int, is_limit: bool, is_num: bool) -> int: if pos == len(digits): # 构造完所有位，如果是一个有效数字（非全前导零），则返回1 return 1 if is_num else 0 res = 0 # 计算当前位可选择的上界 up = int(digits[pos]) if is_limit else 1 # 尝试填入0或1 for d in range(up + 1): next_state = state if is_num or d == 1: if state == 0: next_state = 1 if d == 1 else 0 elif state == 1: next_state = 2 if d == 0 else 1 else: # state == 2 if d == 1: continue # 形成101，非法分支 else: next_state = 0 else: # 还在前导零阶段，状态保持为0 next_state = 0 # 递归到下一位 next_limit = is_limit and d == up next_is_num = is_num or d == 1 res += dfs(pos + 1, next_state, next_limit, next_is_num) return res # Python记忆化技巧：由于is_limit和is_num影响缓存有效性，我们手动控制参数 # 但@lru_cache无法区分 is_limit=True/False 的不同缓存，所以需要调整。 # 标准做法：将dfs定义为接收所有参数的函数，但只在!is_limit and is_num时希望缓存。 # 一个技巧是：将dfs拆分成两个函数，或者使用带参的装饰器。这里我们采用另一种常见写法： # 不直接使用@lru_cache，而是在外层函数f内定义一个内部函数，并手动管理一个字典缓存。 # 但为了代码清晰，我们展示使用@lru_cache并传入所有参数，但需注意它可能会缓存一些受限路径的结果。 # 更严谨的做法如下（手动缓存）： from functools import lru_cache # 我们重新定义一个内部函数，使用lru_cache，但通过参数化来避免限制问题。 # 实际上，对于数位DP，一个更干净的做法是：在调用dfs时，对于is_limit=True的路径，我们不希望它被缓存影响其他路径。 # 因此，我们可以将记忆化逻辑内嵌。 memo = {} def dfs_inner(pos, state, is_limit, is_num): key = (pos, state, is_limit, is_num) if key in memo: return memo[key] if pos == len(digits): return 1 if is_num else 0 res = 0 up = digits[pos] if is_limit else 1 for d in range(up + 1): # ... 状态转移逻辑与上面dfs函数内部相同 ... next_state = state if is_num or d == 1: if state == 0: next_state = 1 if d == 1 else 0 elif state == 1: next_state = 2 if d == 0 else 1 else: if d == 1: continue else: next_state = 0 else: next_state = 0 next_limit = is_limit and d == up next_is_num = is_num or d == 1 res += dfs_inner(pos + 1, next_state, next_limit, next_is_num) # 关键：只缓存不受限制且已开始构造数字的状态 if not is_limit and is_num: memo[key] = res return res return dfs_inner(0, 0, True, False) return f(R) - f(L - 1) # 测试 sol = Solution() print(sol.countValidNumbers(1, 10))

Python实现的核心技巧与“坑”：

1. 二进制转换：bin(X)[2:]是最快最简洁的获取二进制字符串的方法，再通过list(map(int, s))转为列表。
2. 记忆化装饰器@lru_cache：Python的functools.lru_cache非常方便，但直接用它装饰dfs函数会遇到问题。因为dfs的参数包含is_limit和is_num，而lru_cache会把所有参数组合都缓存。这会导致is_limit=True的路径结果被错误地复用到is_limit=False的路径上，或者is_num=False的状态被错误缓存。这是Python实现数位DP最容易出错的地方！
3. 正确的缓存策略：如上代码所示，更安全的做法是使用一个字典memo手动管理缓存。缓存键为(pos, state, is_limit, is_num)，但在存储时，我们只存储not is_limit and is_num情况下的结果。这是因为只有这种状态下的结果才是“通用”的，可以被其他搜索路径复用。
4. 递归深度：Python默认递归深度有限（约1000层）。对于此题，二进制位数最多几十位，远低于限制，无需担心。但对于位数极多的题目，可能需要设置sys.setrecursionlimit。

4. 算法正确性验证与边界测试

写完代码不是终点，验证其正确性至关重要。我们可以通过暴力解法（小范围）来验证数位DP算法的正确性。

暴力验证思路：编写一个辅助函数isValid(x)，判断数字x的二进制是否包含“101”。然后遍历区间[L, R]（R较小，例如<10^5），统计个数。与我们的DP结果对比。

以Python为例：

def brute_force(L, R): def has101(x): # 将x转为二进制字符串，判断是否包含子串“101” return '101' in bin(x)[2:] count = 0 for num in range(L, R+1): if not has101(num): count += 1 return count # 测试几个区间 test_cases = [(1, 10), (1, 100), (100, 200)] for L, R in test_cases: dp_result = sol.countValidNumbers(L, R) bf_result = brute_force(L, R) print(f"[{L}, {R}] DP: {dp_result}, BF: {bf_result}, {'OK' if dp_result == bf_result else 'FAIL'}")

边界条件测试：

1. 最小区间：L=1, R=1。只有数字1，二进制为1，不含“101”，结果应为1。
2. 包含101的区间：L=4, R=6。4(100), 5(101), 6(110)。只有5包含“101”，所以结果应为2。
3. 大区间：L=1, R=10^6。暴力法会很慢，但DP应瞬间出结果。可以对比DP结果与暴力法（在可接受时间内）对小范围（如1到10000）的结果，确保逻辑正确后再推断大范围。
4. L=0的情况：题目通常要求正整数，但我们的f(0)应该返回0（因为0不是正数，且其二进制0也不含“101”，但根据isNum逻辑，f(0)返回0）。确保countValidNumbers(0, R)与countValidNumbers(1, R)结果一致（如果题目要求正整数）。

常见错误排查：

• 结果偏大：通常是因为isNum逻辑处理不当，将数字0或全前导零的路径也计入了结果。检查递归终点return isNum ? 1 : 0。
• 结果偏小：可能是状态转移时，对“前导零”阶段的状态更新有误。确保在!isNum && d==0时，nextState保持为0，不进行“101”模式的匹配。
• 缓存导致错误：检查缓存条件!isLimit && isNum。如果错误地缓存了isLimit=true的状态，会导致后续不同上限路径的结果被错误复用。

5. 性能分析与优化空间

我们实现的数位DP算法已经非常高效。我们来分析一下复杂度：

• 时间复杂度：状态数约为O(pos * state)，其中pos最大为二进制位数m（对于R<=10^9，m<=30），state为3。对于每个状态，我们需要枚举当前位的选择（0或1，最多2种）。并且，由于记忆化的存在，每个(pos, state)组合（在!isLimit && isNum条件下）最多计算一次。因此，时间复杂度为O(m * 3 * 2) = O(m)，即O(logR)，这是对数级别的，极快。
• 空间复杂度：主要用于记忆化数组和递归栈。记忆化数组大小为O(m * 3)，递归栈深度为O(m)。空间复杂度也是O(logR)。

进一步优化思路：

1. 迭代式数位DP：递归+记忆化搜索（记忆化搜索）已经足够清晰和高效。也可以写成自底向上的迭代DP，但代码可能更复杂。在面试或机试中，递归写法更易于理解和编写。
2. 状态压缩：本题状态只有3种，已经很简单。对于更复杂的状态（比如需要记录前k位），可以考虑用位运算压缩。
3. 预处理DP表：如果需要多次查询不同的区间[L, R]，我们可以预处理一个通用的DP表，然后通过f(R) - f(L-1)计算。我们的算法已经做到了这一点，每次f(X)调用是独立的。
4. 语言特定优化：在C++中，可以使用constexpr、内联函数；在Python中，可以使用@lru_cache的maxsize参数，或尝试用迭代减少函数调用开销。但对于本题规模，这些优化带来的提升微乎其微。

实操心得：

• 调试优先写暴力：在实现复杂的数位DP时，我强烈建议先写一个暴力验证函数（用于小数据范围）。每实现一步，就用小数据测试对比，能快速定位逻辑错误。
• 画状态转移图：对于状态state的定义和转移，在纸上画一个简单的状态机图会非常有帮助。明确从每个状态，在输入0或1时，会转移到哪个状态，以及哪些转移是非法的。
• 关注前导零：这是数位DP最容易出错的地方。始终问自己：当前位是前导零吗？它应该参与条件判断（如“不含101”）吗？在我们的问题中，前导零不参与“101”模式的匹配，因此状态保持为0。
• 理解记忆化条件：深刻理解为什么只有!isLimit && isNum的状态才能缓存，这是数位DP的核心精髓之一。isLimit为真意味着当前路径受到原始数字X的位限制，这个结果是“特化”的，不能用于其他数字。

6. 扩展到其他类似问题与总结

掌握了“不含101”的数位DP解法，你可以轻松解决一系列变体问题，它们都可以套用相似的框架：

1. 不含连续1的个数：状态可以简化为state表示上一位是否为1。判断当前位填1时，如果state==1则非法。
2. 不含特定模式：例如“不含111”、“不含010”。只需根据模式长度（比如k位），将state定义为当前匹配到该模式的前几位（0到k-1），在状态转移时判断是否形成完整模式。
3. 含有特定模式的个数：求包含“101”的数的个数。可以用总数减去不含“101”的个数，也可以修改状态机，增加一个“已包含模式”的终止状态，一旦进入该状态，后续位可以任意填。
4. 区间内数字和满足条件的数：不仅统计个数，还要计算这些数的和、平方和等。这时DP状态需要额外携带一个信息，比如当前位之和的模数。

最后一点个人体会：数位DP看似 intimidating，但核心就是“按位决策”+“状态记录”+“记忆化搜索”。多练习几道题，就能掌握其套路。在华为OD或其他机试中，遇到区间统计问题，先想想能不能转化为数位DP，往往能化繁为简。这道“不含101的数”就是一个经典的入门题，希望这份超详细的四语言实现解析，能帮你彻底搞懂它。在实际编码时，建议先用你最熟悉的语言实现并调试通过，再尝试用其他语言复现，这样可以加深对算法本质的理解，而不是死记硬背代码。