树递归：一个问题，两条以上的岔路

0. 本讲导读

上一讲讲完了递归的基本机制：一个函数在自己的函数体里调用自己，靠 base case（基础情形） 收尾，靠递归情形（recursive case）把问题变小。你写过的 sum_digits、factorial、cascade 都长成同一个样子：一次递归调用，把 n 变成 n // 10 或 n - 1，然后对返回值做点加工。

这类递归的调用结构是一条链：fact(4) 叫 fact(3)，fact(3) 叫 fact(2)……一根竹竿，捅到底，再一层层收回来。

但有一大类问题，一条链根本装不下。举个最短的例子：

上 4 级台阶，每次可以迈 1 级或 2 级，一共有几种走法？

你在第 0 级上站着，面前有两个互不相容的选择：迈 1 级，或者迈 2 级。选了哪个，剩下的问题就变成「上 3 级」或者「上 2 级」——都还是同一个问题，只是规模小了。而这两条路上的走法互不重叠（第一步迈 1 的走法，绝不可能同时是第一步迈 2 的走法），所以总数就是两者之和。

关键在于：你不能只走其中一条。两条都得走，两个答案都得要。于是在同一个递归情形里，你必须写下两次递归调用。调用结构不再是一根竹竿，而是一棵倒着长的树——这就是本讲的主角：树递归（tree recursion）。

本讲要回答三个问题：

1. 什么时候该想到树递归？（答案：「数有多少种方法」「试遍所有选择」这类问题）
2. 怎么写出来？（答案：找到一个把可能性劈成互斥两半的「决策点」，每一半发一次递归调用，再合并）
3. 代价是什么？（答案：同一个子问题会被反复重算，次数按指数增长）

往后看：这一讲的思维方式——「枚举选择、合并结果」——会一路用到 Lab 04、HW 02、以及后面的项目里。第 17 讲讲的记忆化（memoization）就是专门用来治本讲第 9 节那个「重复计算」病的。而当你之后学到「树」这个数据结构时（第 9 讲），会发现处理它的函数常常也是树递归——但这是两件不同的事，第 3 节会专门澄清。

1. 热身：cascade 的四个版本，只有两个是对的

先用一道单链递归的题热身，它考的是本课最容易被忽略的一点：递归调用前后的语句，执行时机完全不同。你如果在这道题上还含糊，后面画树递归的调用树时一定会乱。

cascade(123) 要打印出这样的「瀑布」：

123
12
1
12
123

下面四个实现里，哪些能得到上面这个输出？先自己判断，再往下看。

def cascadeA(n):
    if n < 10:
        print(n)
    else:
        print(n)
        cascadeA(n // 10)
        print(n)

def cascadeB(n):
    print(n)
    if n >= 10:
        cascadeB(n // 10)
        print(n)

def cascadeC(n):
    print(n)
    if n < 10:
        cascadeC(n // 10)
        print(n)

def cascadeD(n):
    print(n)
    cascadeD(n // 10)
    print(n)

A 和 B 都对

先看 A。它把两种情况写得明明白白：n < 10（一位数）时只打印一次；否则打印、递归、再打印。

第 5、6 步是全部要点：每一帧都有自己的 n。cascadeA(12) 那一帧里的 n 从头到尾都是 12，不会因为调用了 cascadeA(1) 而变成 1。所以「回来时打印的还是原来那个 n」——瀑布才对称。

Global frame
    cascadeA  ──→ func cascadeA(n)

f1: cascadeA [parent=Global]
    n ──→ 123          当前停在 cascadeA(n // 10) 这一行，等它返回
                       后面还有一句 print(n) 没执行

f2: cascadeA [parent=Global]
    n ──→ 12           当前停在 cascadeA(n // 10) 这一行
                       后面还有一句 print(n) 没执行

f3: cascadeA [parent=Global]
    n ──→ 1            走 if 分支，print(1) 已执行，即将返回 None

注意每一帧的 parent 都是 Global，不是「上一帧」。父帧由函数定义在哪里决定，跟谁调用了它无关——cascadeA 定义在全局，所以它的每一次调用都新建一个 parent 为 Global 的帧。这一点在树递归里更要紧：调用树很深很宽，但所有帧的 parent 全是 Global。

再看 B。它注意到「打印 n」这件事两个分支都要做，于是提到 if 外面去，只在 n >= 10 时才多做「递归 + 再打印」。执行下来输出与 A 完全一样，我在本机跑过：

>>> cascadeB(123)
123
12
1
12
123
>>> cascadeB(5)
5

讲义在这里问了一个不那么技术、但很重要的问题：两个都对，哪个更好？课程给的答案是：A 更可读（readable），B 更简洁（concise）；如果二者只能选一个，95% 的情况下选可读。理由很实在——代码写一遍，读一百遍，而且读的人常常是三个月后的你自己。B 省下的那一行，换来的是「为什么 print 在 if 外面」这个需要想一下才明白的问题。

C 错在把条件写反了

cascadeC 和 B 只差一个符号：if n < 10 而不是 if n >= 10。这一个符号让它彻底坏掉，而且是两种不同的坏法：

>>> cascadeC(5)
5
0
0
0
... （几百行 0）
Traceback (most recent call last):
  ...
RecursionError: maximum recursion depth exceeded while getting the str of an object

这条报错信息值得认识一下。RecursionError 意味着调用栈深度超过了 Python 的默认上限（sys.getrecursionlimit() 通常是 1000）。后面那句 while getting the str of an object 只是说「爆栈的那一刻，解释器正在执行 print 内部的字符串转换」——不要被它误导去查 print 的用法，病根是递归不收敛。

D 连 base case 都没有

cascadeD 干脆把 if 删掉了。它是「无条件递归」的教科书样本：

>>> cascadeD(123)
123
12
1
0
0
0
...
RecursionError: maximum recursion depth exceeded while getting the str of an object

前三行还挺像样，因为 123 → 12 → 1 确实在变小。但到了 cascadeD(1)，没有任何条件拦住它，它照样调用 cascadeD(1 // 10) = cascadeD(0)，然后就永远停在 0 了。

2. 复习：sum_odd_squares，以及「递归怎么记住额外状态」

随堂练习 06.py 里的第一题，要求同一个功能分别用迭代和递归写一遍。它本身不是树递归，但它教了一个之后处处要用的技巧：当递归需要携带一个额外的信息时，用一个 helper 函数多加一个参数。

题面（docstring 的人话版）：给一个非负整数 n，从最右边一位算作第 0 位往左数，奇数位上的数字要平方后再加，偶数位上的数字直接加。

>>> sum_odd_squares_iterative(5)
5
>>> sum_odd_squares_iterative(123)   # 1 + (2*2) + 3 = 8
8
>>> sum_odd_squares_iterative(243580)
86

先把 123 掰开看清楚位置是怎么编号的——位置从右往左数，跟书写顺序相反，这是最容易看错的地方：

合计 1 + 4 + 3 = 8。✓

迭代版

迭代版就是第 2 讲那个 sum_digits 的骨架（反复 % 10 取末位、// 10 砍掉末位），只是多带一个计数器记住「现在扒到第几位了」：

def sum_odd_squares_iterative(n: int) -> int:
    position = 0
    total = 0
    while n > 0:
        digit = n % 10
        if position % 2 == 1:
            total += digit * digit
        else:
            total += digit
        n = n // 10
        position += 1
    return total

追踪 sum_odd_squares_iterative(123)：

顺带回答一个边界：n = 0 时循环一次都不进，返回 0。这恰好是对的——0 的各位数字之和就是 0。

递归版：额外状态往哪放？

递归版有个真实的坎。你很自然会想写：

def sum_odd_squares_recursive(n):
    if n == 0:
        return 0
    return (n % 10) + sum_odd_squares_recursive(n // 10)      # ← 平方在哪判断？

问题立刻暴露：函数只有 n 一个参数，它没法知道「当前这一位是第几位」。迭代版有 position 这个变量一路带着，递归版每一次调用都是崭新的一帧，帧与帧之间不共享局部变量。

你可能想到把位置编码进 n 里——比如「看剩下几位数」。但更直接、也是本课标准做法的，是再加一个参数。既然题目规定了外部接口只能传一个 n，那就在里面定义一个多参数的 helper 函数：

def sum_odd_squares_recursive(n: int) -> int:
    def helper(n: int, is_odd: bool) -> int:
        if n == 0:
            return 0
        elif is_odd:
            return ((n % 10) ** 2) + helper(n // 10, not is_odd)
        else:
            return (n % 10) + helper(n // 10, not is_odd)
    return helper(n, False)

三处细节值得说清楚：

• 为什么传 is_odd 而不是 position？因为我们只关心奇偶，不关心具体是第几位。传布尔值，翻转就是 not is_odd，比 position + 1 再 % 2 少绕一道。两种写法都对。
• 初始值为什么是 False？最右边一位是位置 0，是偶数位，所以第一次调用时「当前不是奇数位」。传 True 会让 sum_odd_squares_recursive(5) 返回 25 而不是 5。
• helper 里的 n 遮蔽了外层的 n。这不是 bug——helper 有自己的形参 n，它的帧里 n 就是自己那个。外层的 n 只在最后 return helper(n, False) 那一次被读到。

helper(123, False)
  = (123 % 10) + helper(12, True)          # 位置 0，偶，不平方
  = 3          + helper(12, True)
                     helper(12, True)
                       = (12 % 10) ** 2 + helper(1, False)   # 位置 1，奇，平方
                       = 4              + helper(1, False)
                                              helper(1, False)
                                                = (1 % 10) + helper(0, True)
                                                = 1        + helper(0, True)
                                                                 helper(0, True) = 0   ← base case
                                                = 1 + 0 = 1
                       = 4 + 1 = 5
  = 3 + 5 = 8                                                   ✓

注意回代的方向：先一路下沉到 helper(0, True) 拿到 0，再一层层往上把加法做完。在 helper(0, True) 返回之前，3 + ... 这个加法一次都没算过——加号左边的 3 早就算好了，右边的操作数还是一个「悬而未决」的调用。这就是为什么帧要留在栈上。

3. 树递归到底是什么

把定义拆成两半读：

• 「超过 1 次递归调用」——数的是代码里写了几个递归调用，不是运行时一共发生了多少次调用。fact(n) 会调用自己 n 次，但代码里只写了一处 fact(n - 1)，所以它不是树递归。
• 「在单个递归情形里」——如果一个函数有两个分支，分支 A 里写了一次递归调用，分支 B 里也写了一次，但每次执行只走其中一条，那它也不是树递归，因为任何一次调用都只发出一个「儿子」。

为什么叫「树」：把「谁调用了谁」画成图，一个调用是一个结点，它发出的每次递归调用是一条向下的边。单链递归画出来是一条竖线；两个调用画出来就是每个结点分两个叉，整体像一棵倒栽的树——根在最上面（最初的那次调用），叶子在最下面（各个 base case）。

单链递归 fact(4)              树递归 fib(4)

  fact(4)                        fib(4)
    │                           ╱      ╲
  fact(3)                  fib(3)      fib(2)
    │                     ╱     ╲      ╱    ╲
  fact(2)             fib(2)   fib(1) fib(1) fib(0)
    │                ╱     ╲
  fact(1)        fib(1)   fib(0)
    │
  fact(0)   ← 叶子只有 1 个       ← 叶子有 5 个

什么样的题该往树递归上想

把这三条翻译成做题时的自问自答：

4. Fibonacci：把调用树整棵画出来

Fibonacci（斐波那契）数列的定义本身就是递归的：

• 第 0 个是 0
• 第 1 个是 1
• 第 n 个 = 前两个之和

即 0, 1, 1, 2, 3, 5, 8, 13, …。第 3 讲写过迭代版：

def fib(n):
    curr, nxt = 0, 1
    k = 0
    while k < n:
        curr, nxt = nxt, curr + nxt
        k += 1
    return curr

这个迭代版是对的，也快，但它跟数学定义之间隔着一层需要动脑筋的翻译：你得想明白 curr, nxt 这两个变量在循环里滚动地代表着什么。而递归版几乎是把定义抄下来——三个 clause 分别对应定义里的三条：

def fib(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib(n - 1) + fib(n - 2)

这是本讲第一个真正的树递归——else 分支里出现了两个 fib 调用。

为什么需要两个 base case？因为递归情形要往回够两格。如果只写 if n == 0: return 0，那么 fib(1) 会去算 fib(0) + fib(-1)，而 fib(-1) 又会去算 fib(-2) + fib(-3)……一路奔向负无穷。规则：递归情形每次最多往回退 k 格，就至少要有 k 个连续的 base case 挡住。

手工展开 fib(4)

下面这段是本节的核心，请一行一行读。缩进代表调用的深度：

fib(4)
= fib(3) + fib(2)                     ← 先把左边的 fib(3) 算完，右边一动不动地等着

  fib(3) = fib(2) + fib(1)
    fib(2) = fib(1) + fib(0)
      fib(1) = 1                      ← base case
      fib(0) = 0                      ← base case
    fib(2) = 1 + 0 = 1
    fib(1) = 1                        ← base case
  fib(3) = 1 + 1 = 2

  fib(2) = fib(1) + fib(0)            ← 现在才轮到最外层那个右操作数
    fib(1) = 1
    fib(0) = 0
  fib(2) = 1 + 0 = 1

= 2 + 1 = 3                           ✓  数列 0,1,1,2,3 的第 4 项确实是 3

这里藏着一个必须说清的求值顺序问题。return fib(n - 1) + fib(n - 2) 是一个加法表达式，Python 求值它时：先完整求值左操作数 fib(n - 1)（这意味着把左边那整棵子树跑到底），再求值右操作数 fib(n - 2)，最后才做加法。两个调用不是并行的，是严格一前一后。

所以任何时刻，栈上其实只有一条从根到当前结点的路径——树的最大深度是 n，栈最深也就 n 层。「树很宽」和「栈很深」是两回事：宽度带来的是时间开销，深度带来的才是空间开销。

Global frame
    fib ──→ func fib(n)

f1: fib [parent=Global]   n ──→ 4   正在算 fib(n-1)，加号右边的 fib(2) 还没碰
f2: fib [parent=Global]   n ──→ 3   正在算 fib(n-1)，加号右边的 fib(1) 还没碰
f3: fib [parent=Global]   n ──→ 2   正在算 fib(n-1)，加号右边的 fib(0) 还没碰
f4: fib [parent=Global]   n ──→ 1   走 elif 分支，即将返回 1

栈深 4 层，而不是「fib(4) 的整棵树有 9 个结点所以 9 层」。

数一数：同一个子问题被算了几遍

课上让大家去 recursionvisualizer.com 跑一次 virfib(5)，然后问「你注意到了什么」。（vir 取自 Virahanka，最早提出这个数列的印度数学家。）要注意到的就是：调用树上有大量长得一模一样的子树，同一个 fib(k) 被从头算了很多次。

把 fib(5) 的调用树画全（每个结点写它的参数）：

                        fib(5)
                 ╱                  ╲
            fib(4)                   fib(3)
          ╱        ╲               ╱       ╲
     fib(3)        fib(2)      fib(2)      fib(1)
    ╱     ╲       ╱     ╲     ╱     ╲
 fib(2)  fib(1) fib(1) fib(0) fib(1) fib(0)
 ╱    ╲
fib(1) fib(0)

我在本机加了一个计数器实际跑了一遍 fib(5)，各参数被调用的次数是：

算一个 fib(5)（结果才是 5）要发生 15 次函数调用，其中 fib(1) 被从零开始算了 5 遍。这不是实现写得糙——这是这个递归结构的固有代价。往大了看更吓人：

前三行是我实际跑出来的计数，最后一行按公式推的。这个公式本身很漂亮，也值得记：计算 fib(n) 所需的调用次数恰好是

验证一下：$C(5) = 2 \cdot \mathrm{fib}(6) - 1 = 2 \cdot 8 - 1 = 15$ ✓；$C(30) = 2 \cdot \mathrm{fib}(31) - 1 = 2 \cdot 1346269 - 1 = 2692537$ ✓。

为什么是这个式子？因为这棵树的叶子全是 fib(1)（返回 1）或 fib(0)（返回 0），而最终结果是所有叶子值之和，所以返回 1 的叶子恰好有 $\mathrm{fib}(n)$ 个。再加上返回 0 的叶子，总叶子数是 $\mathrm{fib}(n+1)$（这里用到 $\mathrm{fib}(n) + \mathrm{fib}(n-1) = \mathrm{fib}(n+1)$）。最后套用二叉树的性质：每个内部结点都恰好有 2 个儿子的二叉树，结点总数 = 2 × 叶子数 − 1。

由于 $\mathrm{fib}(n)$ 本身按黄金比例 $\varphi = \frac{1+\sqrt{5}}{2} \approx 1.618$ 的幂次增长，调用次数是 $\Theta(\varphi^n)$——指数级。n 每增加 1，工作量乘以约 1.618；n 每增加 15，工作量翻大约一千倍。

def fib(n):
    if n == 0:
        return 1        # ✗ 应该是 0
    elif n == 1:
        return 1
    return fib(n - 1) + fib(n - 2)

def fib(n):
    if n == 0:
        return 0
    return fib(n - 1) + fib(n - 2)

>>> fib(5)
Traceback (most recent call last):
  ...
RecursionError: maximum recursion depth exceeded in comparison

5. count_partitions：从「选或不选」到三个 base case

fib 是「数学定义天生递归」的例子，你几乎不用动脑就能抄出来。count_partitions 不一样——它的递归结构需要你自己发明。这是本讲最重要的一道题，也是 61A 的经典题目。

题目：正整数 n 用不超过 m 的部分（part）做划分（partition）的方案数，是指把 n 写成若干个不超过 m 的正整数之和、且这些数按递增顺序排列的写法总数。

例如 count_partitions(6, 4) == 9：

先把「递增顺序」这个约定的作用说透：它不是在限制答案的形式，而是在定义什么算「同一种划分」。2 + 4 和 4 + 2 是同一个划分的两种写法，规定按递增排列后就只剩一种。少了这个约定，count_partitions(6, 4) 数出来的就是完全不同的东西（那叫 composition，组合数会大得多）。

找到那个分叉点

面对这道题，第一反应往往是想「怎么把 n 变小」。n - 1？n // 2？都走不通，因为你根本不知道下一个部分该取多大。

换个问法：能不能问一个「是/否」问题，把 9 种划分干净地劈成两堆？

看上面那张表的最后一列——问题就在那儿：「这个划分里，用没用到最大的那个尺寸 m（这里是 4）？」

• 用了至少一个 4：第 1、2 两种。
• 一个 4 都没用：第 3 到 9 种，共 7 种。

2 + 7 = 9。互斥（一个划分不可能既用了 4 又没用 4），穷尽（不存在第三种情况）。这正是第 3 节说的「情况 A + 互斥的情况 B」。

接下来把这两堆各自变成一个同类型的、更小的子问题：

base case：一个一个补出来

讲义把这份代码分了 4 张幻灯片，从只有 else 分支开始，一次补一个 base case。这个顺序值得原样复述一遍，因为它展示的正是真实的写代码过程：先写递归情形，再问「什么时候递归该停」。

def count_partitions(n, m):
    ...
    else:
        with_m = count_partitions(n - m, m)
        without_m = count_partitions(n, m - 1)
        return with_m + without_m

def count_partitions(n, m):
    if n == 0:
        return 1
    elif n < 0:
        return 0
    elif m == 0:
        return 0
    else:
        with_m = count_partitions(n - m, m)
        without_m = count_partitions(n, m - 1)
        return with_m + without_m

完整展开一个小例子

count_partitions(6, 4) 的树有 59 个结点（我加计数器数过），太大画不下。换个能画全的：count_partitions(4, 2)，答案应该是 3（4 = 2+2、4 = 1+1+2、4 = 1+1+1+1）。

cp(4,2)
├── with_m    = cp(2,2)          # 用了一个 2，还剩 2 要凑
│   ├── with_m    = cp(0,2)  → 1     ← n == 0，成功！对应 4 = 2+2
│   └── without_m = cp(2,1)
│       ├── with_m    = cp(1,1)
│       │   ├── with_m    = cp(0,1) → 1   ← 成功，对应 4 = 2+1+1
│       │   └── without_m = cp(1,0) → 0   ← m == 0，没尺寸可用了
│       │   小计 cp(1,1) = 1 + 0 = 1
│       └── without_m = cp(2,0) → 0       ← m == 0
│       小计 cp(2,1) = 1 + 0 = 1
│   小计 cp(2,2) = 1 + 1 = 2
└── without_m = cp(4,1)          # 一个 2 都不用，只能用 1
    ├── with_m    = cp(3,1)
    │   ├── with_m    = cp(2,1) = 1       ← 同上，展开略；对应 4 = 1+1+1+1
    │   └── without_m = cp(3,0) → 0
    │   小计 cp(3,1) = 1
    └── without_m = cp(4,0) → 0
    小计 cp(4,1) = 1 + 0 = 1

cp(4,2) = 2 + 1 = 3   ✓

把每个返回 1 的叶子和一种真实划分对上号，是理解这道题最有效的方式：

顺手记几个可以自查的值（都是我跑出来的）：count_partitions(6, 4) == 9，count_partitions(6, 6) == 11，count_partitions(5, 5) == 7，count_partitions(2, 3) == 2。

最后一个值得琢磨：count_partitions(2, 3) 里 m > n。第一支 cp(2 - 3, 3) = cp(-1, 3) 撞上 n < 0 返回 0（合理：2 根本装不下一个 3），第二支 cp(2, 2) = 2。总共 2 种，正是 2 = 2 和 2 = 1 + 1。不需要为「m 比 n 大」写特判——n < 0 那条 base case 已经把它顺手处理了。

6. 练习：count_stairs

题目：你要爬 n 级台阶，每次可以迈 1 级或 2 级。一共有多少种不同的走法？

>>> count_stairs(3)   # 2 then 1；1 then 2；或 1, 1, 1
3
>>> count_stairs(2)   # 迈 2 级；或迈两次 1 级
2
>>> count_stairs(4)
5

怎么想到的

套第 3 节那三个自问：

于是：

• 第一步迈 1 级 → 站在第 1 级上，还剩 n - 1 级要爬 → count_stairs(n - 1) 种
• 第一步迈 2 级 → 站在第 2 级上，还剩 n - 2 级要爬 → count_stairs(n - 2) 种

关键的一步在于承认：「站在第 1 级上，还剩 n−1 级要爬」跟「站在地面，要爬 n−1 级」是完全同一个问题。台阶不记得你是怎么上来的，剩下的选择完全一样。这种「历史无关」正是问题能被递归拆开的前提——如果规则是「不能连续迈两次 1 级」，那就得再带一个参数记住上一步迈了几级。

base case

递归情形往回退两格，所以至少需要两个连续的 base case（第 4 节讲过的规则）。06-sol.py 里的写法是把它们合成一行：

def count_stairs(n: int) -> int:
    # If you're 1 step away from the top or already at the top,
    # there's only 1 way to get there
    if n == 1 or n == 0:
        return 1
    return count_stairs(n - 1) + count_stairs(n - 2)

• n == 1 → 1：只剩 1 级，只能迈 1 级上去，1 种走法。
• n == 0 → 1：已经在顶上了，什么都不用做，这本身算 1 种走法。

n == 0 返回 1 而不是 0，是这道题最容易卡住的地方。想通它有两条路：

另一种同样正确、而且更容易推广的写法是把「越界」单独拎出来：

def count_stairs(n):
    if n < 0:
        return 0        # 迈过头了，走不通
    elif n == 0:
        return 1        # 正好到顶，记一种
    return count_stairs(n - 1) + count_stairs(n - 2)

我把两个版本对 n = 0..7 都跑了一遍，结果完全一致：1, 1, 2, 3, 5, 8, 13, 21。第二种写法的好处是骨架能直接搬到「每次可迈 1、2 或 3 级」上去——只要加一个 count_stairs(n - 3)，base case 一个字都不用改。第一种写法就得再补一个 n == 2。

def count_stairs(n):
    if n == 1:
        return 1
    elif n == 2:
        return 2
    return count_stairs(n - 1) + count_stairs(n - 2)

>>> count_stairs(0)
Traceback (most recent call last):
  ...
RecursionError: maximum recursion depth exceeded in comparison

验证 count_stairs(4)

cs(4) = cs(3) + cs(2)

  cs(3) = cs(2) + cs(1)
    cs(2) = cs(1) + cs(0)
      cs(1) = 1            ← base case
      cs(0) = 1            ← base case
    cs(2) = 1 + 1 = 2
    cs(1) = 1
  cs(3) = 2 + 1 = 3

  cs(2) = cs(1) + cs(0) = 1 + 1 = 2

cs(4) = 3 + 2 = 5    ✓

把 5 种走法列出来对一下：1+1+1+1、1+1+2、1+2+1、2+1+1、2+2。正好 5 种。注意 1+1+2 和 2+1+1 算两种——这里顺序是有意义的，跟 count_partitions 里「递增顺序」的约定刚好相反。

7. 练习：mario_number

题目：关卡用一个只由 0 和 1 组成的整数表示，0 是食人花（Piranha plant），踩上去就死。Mario 从最左位出发（题目保证是 1），必须停在最右位（题目保证也是 1）。每一步可以 step（前进一格）或 jump（前进两格）。问有多少种不踩到食人花的走法。

>>> mario_number(10101)    # jump, jump
1
>>> mario_number(11101)    # 从左到右：step, step, jump 或 jump, jump
2
>>> mario_number(100101)
0

先解决 Hint：为什么必须从右往左

这道题的骨架跟 count_stairs 几乎一样（每步走 1 格或 2 格，数走法），唯一多出来的是「有些格子不能踩」。难点不在递归结构，在怎么把「去掉一格」这个操作用整数算术表达出来。

手上只有整数运算，能砍数字的只有两招：

「致命问题」是前导零会被整数悄悄吃掉。以 10101 为例，砍掉最左那位应该得到关卡 0101，但作为整数它就是 101——那个 0（食人花）凭空消失了，关卡长度从 4 变成 3。这种 bug 不报错，只是答案错，最难查。

所以答案是：从右往左走。反过来看 Mario 的路径完全等价——一条从左到右的路径倒过来，就是一条从右到左、每步同样走 1 格或 2 格的路径，一一对应，数量相同。而从右往左，「走过一格」正好就是 // 10。

代码

def mario_number(level: int) -> int:
    if level == 1:
        return 1
    elif level % 10 == 0:
        return 0
    else:
        step = mario_number(level // 10)
        jump = mario_number(level // 100)
        return step + jump

逐行说为什么：

• if level == 1: return 1——关卡只剩 Mario 的起点这一格了，他已经站在这儿，不用走，这本身是 1 种完整走法。跟 count_stairs(0) == 1 同一个道理。
  （为什么判 == 1 而不是 < 10？题目保证关卡以 1 开头，而从右边砍永远只会剩下原关卡的前缀，前缀的第一位还是 1。所以能出现的单位数只有 1 和 0，后者由下一条处理。）
• elif level % 10 == 0: return 0——level % 10 是最右一位，也就是这个子问题里 Mario 要落脚的那一格。是 0 就是食人花，落不了脚，这条路贡献 0 种走法。
  这一条还顺手兜住了越界：level // 100 有可能把数字砍成 0（比如 mario_number(11) 里 11 // 100 == 0），而 0 % 10 == 0，返回 0。语义正好对：「从起点左边跳进来」是不存在的走法。
• 递归情形——两个到达方式各发一次调用，相加返回。写成两个有名字的变量（step / jump）而不是挤成一行，是为了让读代码的人一眼看出这两支各代表什么，跟第 1 节 cascade 那里说的「选可读」是同一条原则。

验证 mario_number(11101)

关卡 11101 的格子从左到右是 1 1 1 0 1，下标 0 到 4。人工枚举：从 0 出发，走到 4，不能踩下标 3（那是 0）。可行路径是 0→1→2→4（step, step, jump）和 0→2→4（jump, jump），共 2 种。

mario_number(11101)          末位 1，安全，继续
├── step = mario_number(1110)
│      末位 0 → 食人花 → 返回 0        （不能 step 落到下标 3）
└── jump = mario_number(111)
    │  末位 1，安全，继续
    ├── step = mario_number(11)
    │   │  末位 1，安全，继续
    │   ├── step = mario_number(1)   → 1     ← base case，走通了
    │   └── jump = mario_number(0)   → 0     ← 0 % 10 == 0，越过了起点
    │   mario_number(11) = 1 + 0 = 1
    └── jump = mario_number(1)       → 1     ← base case，走通了
    mario_number(111) = 1 + 1 = 2

mario_number(11101) = 0 + 2 = 2      ✓

两片走通的叶子，正好对应上面人工枚举出的两条路径。再看另外两个 doctest：

8. 树递归的通用套路与自查清单

把前面四道题（fib、count_partitions、count_stairs、mario_number）并排放在一起，骨架完全一样：

fib 在这张表里是个特例——它没有真正的「决策」，只是数学递推恰好长成两个调用。另外三道都严格遵循同一个模板：

def solve(状态):
    if 这条路走通了:
        return 1
    if 这条路走死了:
        return 0
    分支A = solve(做了选择 A 之后的状态)
    分支B = solve(做了选择 B 之后的状态)
    return 分支A + 分支B

调试自查清单

树递归写错了往往只体现为「答案差一点」，比死循环还难查。按下面的顺序排查：

def count_stairs(n):
    if n == 1 or n == 0:
        return 1
    count_stairs(n - 1) + count_stairs(n - 2)   # ✗ 算了，但没 return

>>> count_stairs(4)
>>> print(count_stairs(4))
None

TypeError: unsupported operand type(s) for +: 'NoneType' and 'NoneType'

total = 0
def count_stairs(n):
    global total
    if n == 1 or n == 0:
        total += 1
    else:
        count_stairs(n - 1)
        count_stairs(n - 2)

9. 代价：同一个子问题被算了几千遍

回到第 4 节那张表：fib(30) 要 2 692 537 次调用，fib(50) 要约 4 × 10¹⁰ 次。这个开销来自一件很蠢的事——同一个子问题被从零开始重算了无数遍。

看 fib(5) 那棵树：fib(3) 这棵子树出现了 2 次，fib(2) 出现了 3 次，fib(1) 出现了 5 次。而 fib(3) 的答案是 2，第一次算出来之后，第二次完全可以直接抄。可朴素递归不记事，每次都老老实实从头再来。

                        fib(5)
                 ╱                  ╲
            fib(4)                  fib(3) ★  ← 和左边深处那个 fib(3) 完全一样
          ╱        ╲               ╱      ╲
     fib(3) ★     fib(2) ★    fib(2) ★   fib(1)
    ╱     ╲       ╱     ╲     ╱     ╲
 fib(2)★ fib(1) fib(1) fib(0) fib(1) fib(0)
 ╱    ╲
fib(1) fib(0)

fib(1) 被完整计算了 5 次，fib(0) 3 次，fib(2) 3 次，fib(3) 2 次。

为什么树递归特别容易撞上这个？因为不同的决策序列可能走到同一个状态。爬楼梯时「先 1 后 2」和「先 2 后 1」都会让你站在第 3 级上，剩下的子问题一模一样，但递归会把这两条路各自往下走到底。

治法预告：记住算过的答案

解决办法叫记忆化（memoization）：拿一个字典把「算过的参数 → 结果」存起来，下次先查表。第 17 讲会正式讲，这里先看一眼它的威力有多大——下面这段我在本机跑过：

def memo(f):
    cache = {}
    def memoized(n):
        if n not in cache:
            cache[n] = f(n)
        return cache[n]
    return memoized

def fib(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    return fib(n - 1) + fib(n - 2)

fib = memo(fib)          # 把名字 fib 重新绑定到包装后的版本上

从 269 万次降到 31 次，代码本体一个字没改。之所以恰好是 31 次，是因为 n 只有 0 到 30 这 31 个可能的取值，每个值真正算一次，其余全部命中缓存。

这里有个容易忽略但很关键的细节：fib = memo(fib) 这一句必须把结果绑回 fib 这个名字。因为 fib 的函数体里写的是 fib(n - 1)——它在调用时去全局帧查 fib 这个名字，查到的是那一刻绑定的值。重新绑定之后，递归调用自动走的就是带缓存的那个版本了。如果写成 fast_fib = memo(fib)，内部的递归调用仍然指向没缓存的原版，加速就只发生在最外面一层，等于没加速。（第 3 讲讲的「名字在求值时才查找」，在这里结出了果实。）

递归的另一面：它不只是算数字

本讲最后，课程演示了一个真实世界的递归应用——维基百科哲学现象（Wikipedia Philosophy Phenomenon）：在约 97% 的英文维基条目上，不停点击正文里的第一个链接，最终都会走到 Philosophy 这一条。

随堂代码 06-wikipedia.py 把这个过程写成了递归。它的骨架值得看，因为它的 base case 比课堂例题多，而且每一个都对应一种真实世界里会发生的意外：

def find_philosophy(current_url, visited=None, depth=0, max_depth=50):
    if visited is None:
        visited = set()
    # Base Case 1: 到达 Philosophy —— 成功
    # Base Case 2: depth >= max_depth —— 走太久了，放弃
    # Base Case 3: current_url in visited —— 兜圈子了，放弃
    # Base Case 4: 页面上找不到任何可用链接 —— 死胡同，放弃
    ...
    return find_philosophy(next_link, visited, depth + 1, max_depth)   # 递归情形

三点值得留意（这个 demo 是老师让 Gemini 写完再改的，课程明确说不要求看懂全部代码）：

• 它不是树递归——每次只跟一个链接，递归情形里只有一次调用，是一根链。课上顺手抛了个问题：如果改成搜索前 2 个（或前 n 个）链接呢？那就变成树递归了：一个页面发出 n 次递归调用，合并方式从「返回那一条路的结果」变成「任一条通了就算通」（or）。
• visited 这个集合是必需的，因为网页链接会成环（A 的第一个链接指向 B，B 的第一个链接指向 A）。max_depth 是第二道保险。现实世界的递归常常需要这种「防走不动」的 base case，而课堂题目里参数单调变小，天然就有保证。
• visited=None 然后在函数体里 visited = set()，而不是直接写 visited=set() 当默认参数——这是 Python 的一个著名坑（可变默认参数在多次调用间被共享），第 8 讲讲可变性时会算总账。

10. 本讲小结

本讲出现过的四份代码（都能直接跑）

def fib(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib(n - 1) + fib(n - 2)


def count_partitions(n, m):
    if n == 0:
        return 1
    elif n < 0:
        return 0
    elif m == 0:
        return 0
    else:
        with_m = count_partitions(n - m, m)
        without_m = count_partitions(n, m - 1)
        return with_m + without_m


def count_stairs(n):
    if n == 1 or n == 0:
        return 1
    return count_stairs(n - 1) + count_stairs(n - 2)


def mario_number(level):
    if level == 1:
        return 1
    elif level % 10 == 0:
        return 0
    else:
        step = mario_number(level // 10)
        jump = mario_number(level // 100)
        return step + jump

11. 动手练习

练习 1：判断是不是树递归

下面四个函数，哪些是树递归的？

def a(n):
    if n == 0:
        return 0
    return n % 10 + a(n // 10)

def b(n):
    if n < 2:
        return n
    if n % 2 == 0:
        return b(n // 2)
    else:
        return b(n - 1)

def c(n):
    if n <= 0:
        return 1
    return c(n - 1) + c(n - 1)

def d(n, k):
    if k == 0 or n == 0:
        return 1
    return d(n - 1, k) + d(n, k - 1)

练习 2：手算 count_partitions(5, 3)

不许跑代码，用「用不用 3」这个决策把它展开，算出 count_partitions(5, 3)，并把每一种划分写出来验证。

cp(5,3) = cp(2,3) + cp(5,2)          # 用一个 3，剩 2；或不用 3，最大降到 2

  cp(2,3) = cp(-1,3) + cp(2,2)
          = 0        + cp(2,2)        # -1 < 0 → 0（2 装不下一个 3）
    cp(2,2) = cp(0,2) + cp(2,1)
            = 1       + cp(2,1)       # n == 0 → 1，对应 5 = 2+3
      cp(2,1) = cp(1,1) + cp(2,0)
              = cp(1,1) + 0           # m == 0 → 0
        cp(1,1) = cp(0,1) + cp(1,0) = 1 + 0 = 1     # 对应 5 = 1+1+3
      cp(2,1) = 1
    cp(2,2) = 1 + 1 = 2
  cp(2,3) = 0 + 2 = 2

  cp(5,2) = cp(3,2) + cp(5,1)
    cp(3,2) = cp(1,2) + cp(3,1)
      cp(1,2) = cp(-1,2) + cp(1,1) = 0 + 1 = 1      # 对应 5 = 1+2+2
      cp(3,1) = cp(2,1) + cp(3,0) = 1 + 0 = 1       # 对应 5 = 1+1+1+2
    cp(3,2) = 1 + 1 = 2
    cp(5,1) = cp(4,1) + cp(5,0) = 1 + 0 = 1         # 对应 5 = 1+1+1+1+1
  cp(5,2) = 2 + 1 = 3

cp(5,3) = 2 + 3 = 5   ✓

练习 3：改造 count_stairs

现在每次可以迈 1 级、2 级或 3 级。写出 count_stairs3(n)，并算出 count_stairs3(4)。

def count_stairs3(n):
    if n < 0:
        return 0
    elif n == 0:
        return 1
    return count_stairs3(n - 1) + count_stairs3(n - 2) + count_stairs3(n - 3)

练习 4：找 bug

下面这个 count_partitions 只跟正确版本差三个字符，跑出来 count_partitions(6, 4) 得 2 而不是 9。指出错在哪；然后回答一个更有意思的问题：它数出来的那 2 种，究竟是哪 2 种？

def count_partitions(n, m):
    if n == 0:
        return 1
    elif n < 0:
        return 0
    elif m == 0:
        return 0
    else:
        with_m = count_partitions(n - m, m - 1)
        without_m = count_partitions(n, m - 1)
        return with_m + without_m

练习 5：换一种合并方式

把 count_stairs 改成 can_reach(n, forbidden)：仍然每次迈 1 级或 2 级，但第 forbidden 级是坏的，不能踩（可以跨过去）。返回 True 或 False，表示能不能从地面（第 0 级）到达第 n 级。假设 0 < forbidden < n。

def can_reach(n, forbidden):
    if n == forbidden:
        return False       # 这一级踩不得，这条路走死了
    elif n == 0:
        return True        # 回到地面，说明整条路径合法
    elif n < 0:
        return False       # 迈过头了
    return can_reach(n - 1, forbidden) or can_reach(n - 2, forbidden)