动态规划解爬楼梯问题：从递归到矩阵快速幂-优快云博客

1. 问题背景与核心思路

爬楼梯问题是一个经典的算法入门题目，也是理解动态规划思想的绝佳案例。假设你正在爬楼梯，每次可以跨1个或2个台阶，问到达第n个台阶有多少种不同的方法？这个看似简单的问题背后蕴含着递归、数学归纳和动态规划等多个计算机科学核心概念。

我第一次接触这个问题是在准备技术面试时，当时被要求用多种方法实现。最直观的递归解法虽然简单，但在n较大时会出现严重的性能问题。后来通过引入动态规划优化，执行时间从指数级降到了线性级，这个优化过程让我深刻理解了算法优化的艺术。

2. 基础解法：递归思路分析

2.1 问题分解与递推关系

当我们站在第n个台阶时，只可能是从第n-1个台阶跨1步上来，或者从第n-2个台阶跨2步上来。因此，到达第n个台阶的方法数f(n) = f(n-1) + f(n-2)。这就是斐波那契数列的递推关系。

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

2.2 递归解法的问题

虽然递归解法直观易懂，但存在严重的性能缺陷。以n=5为例，计算过程会重复计算f(3)、f(2)等子问题。时间复杂度达到O(2^n)，空间复杂度O(n)（调用栈深度）。

实际测试：当n=40时，普通递归解法在我的笔记本上需要约30秒才能计算出结果，完全无法满足实际需求。

3. 动态规划优化方案

3.1 动态规划基本思想

动态规划通过存储子问题的解来避免重复计算，通常有两种实现方式：

自顶向下的记忆化搜索（Memoization）
自底向上的迭代方法

3.2 记忆化搜索实现

def climbStairs(n):
    memo = {}
    def helper(n):
        if n in memo: return memo[n]
        if n == 1: return 1
        if n == 2: return 2
        memo[n] = helper(n-1) + helper(n-2)
        return memo[n]
    return helper(n)

这种方法的时间复杂度降为O(n)，因为每个子问题只计算一次。空间复杂度O(n)用于存储备忘录。

3.3 迭代法实现

更高效的方式是自底向上计算，只需要存储前两个状态：

def climbStairs(n):
    if n == 1: return 1
    a, b = 1, 2
    for _ in range(2, n):
        a, b = b, a + b
    return b

这种方法的空间复杂度优化到O(1)，只使用常数空间，是面试中最推荐的写法。

4. 数学方法与性能极限

4.1 斐波那契数列通项公式

爬楼梯问题实质是求斐波那契数列的第n+1项。斐波那契数列有精确的数学公式：

f(n) = [ (1+√5)/2 ]^n / √5 - [ (1-√5)/2 ]^n / √5

但由于浮点数精度问题，直接计算在n较大时会出现误差。

4.2 矩阵快速幂解法

更高效的是O(logn)的矩阵快速幂方法：

def climbStairs(n):
    def matrix_pow(mat, power):
        result = [[1,0],[0,1]]
        while power > 0:
            if power % 2 == 1:
                result = matrix_mult(result, mat)
            mat = matrix_mult(mat, mat)
            power //= 2
        return result
    
    def matrix_mult(a, b):
        return [
            [a[0][0]*b[0][0] + a[0][1]*b[1][0],
             a[0][0]*b[0][1] + a[0][1]*b[1][1]],
            [a[1][0]*b[0][0] + a[1][1]*b[1][0],
             a[1][0]*b[0][1] + a[1][1]*b[1][1]]
        ]
    
    if n == 1: return 1
    mat = [[1,1],[1,0]]
    result = matrix_pow(mat, n-1)
    return result[0][0]

这种方法虽然代码复杂，但在处理极大n时（如n=10^18）仍能快速计算。

5. 变种问题与实际应用

5.1 步数限制变化

如果每次可以走1、2或3步，递推关系变为f(n)=f(n-1)+f(n-2)+f(n-3)。动态规划思路依然适用，只需调整状态转移方程。

def climbStairs(n):
    if n == 1: return 1
    if n == 2: return 2
    if n == 3: return 4
    a, b, c = 1, 2, 4
    for _ in range(3, n):
        a, b, c = b, c, a + b + c
    return c