递归在跳变台阶问题中的运用

递归 Recursion

在编程语言中，递归的概念无法用抽象的语言让人一目了然，甚至知道它的意思后，也根本无法理解它为什么名字叫做“递归”。这里我们根据图示，用现实中的一个现象来阐述一下什么叫递归。假设我们在行军打仗中，匍匐着 F、D、C、B、A 这 5 个士兵，F 迷失了自己，不知道自己埋伏在第几个位置。这时他向 D 询问，然后 D 也不知道，再然后向 C ，C 再向 B 询问，最后询问到 A ，A 肯定知道我是第 1 个，然后 B 知道自己是第 2 个，即 C 是第 3 个，D 是第 4 个，F 是第 5 个，那么这个问题就解决了。那么 F->D->C->B->A 谓之递，A->B->C->D->E 谓之归，这就是递归的由来。

递归解决变跳台阶的问题

变跳台阶的问题：假如有 n 个台阶，这里每次你可以跨 1 个台阶或者 2 个台阶，请问走这 n 个台阶有多少种走法？

分析

首先如果我们有一个台阶，那么我们就只有一种走法，即 f(1)=1；如果有 2 个台阶，那么我们也只有两个走法，一种是直接跨 2 个台阶，一种是跨两次 1 个台阶，即 f(2)=2；那么台阶的方案我们就可以设想成：第 n 个台阶是第 n-1 个台阶跨 1 步上来的所有方案 + 第 n-2 个台阶跨 2 步上来的所有方案之和：$f(n)=f(n-1)+f(n-2)$ ，这样我们就形成了一个递归解决思路。

程序实现

class StepRecursion:
    def get_steps_methods(self, steps):
        if steps <= 2:
            return steps
        else:
            return self.get_steps_methods(steps - 1) + self.get_steps_methods(steps - 2)


if __name__ == "__main__":
    step = StepRecursion()
    for i in range(1, 25):
        print("跨 %d 个台阶有 %d 种方案" % (i, step.get_steps_methods(i)))

运行结果

跨 1 个台阶有 1 种方案
跨 2 个台阶有 2 种方案
跨 3 个台阶有 3 种方案
跨 4 个台阶有 5 种方案
跨 5 个台阶有 8 种方案
跨 6 个台阶有 13 种方案
跨 7 个台阶有 21 种方案
跨 8 个台阶有 34 种方案
跨 9 个台阶有 55 种方案
跨 10 个台阶有 89 种方案
跨 11 个台阶有 144 种方案
跨 12 个台阶有 233 种方案
跨 13 个台阶有 377 种方案
跨 14 个台阶有 610 种方案
跨 15 个台阶有 987 种方案
跨 16 个台阶有 1597 种方案
跨 17 个台阶有 2584 种方案
跨 18 个台阶有 4181 种方案
跨 19 个台阶有 6765 种方案
跨 20 个台阶有 10946 种方案
跨 21 个台阶有 17711 种方案
跨 22 个台阶有 28657 种方案
跨 23 个台阶有 46368 种方案
跨 24 个台阶有 75025 种方案

递归的弊端

由变跳台阶问题，我们定义一个概念叫深度，即一个台阶我们说深度为 1 ，两个台阶我们说深度为 2，那么 n 个台阶深度就为 n 。我们从这里可以看出来，递归可以把人脑无法描述的思路变得很简单。但随着深度的增加，求出的方案成指数级增加，那么意味着它在计算机中占用的内存也是指数级别的，解决问题的时间复杂复杂度也是指数级增加。这样计算机就会产生一种叫堆栈溢出的问题，最终导致程序崩溃的灾难性后果。遗憾的是，这个深度的把控却没有很好的解决方法，只能一层一层往上增加测试，估算出计算机所能承受的最大值。