编程题-爬楼梯(递归策略)_爬楼梯编程-优快云博客

爬楼梯：

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

解答一：

由题目信息可知，当需要n阶才能达到顶楼，其前一步可以是爬1个台阶，即在n-1个台阶处；或者2个台阶，即在n-2个台阶处。若爬到顶楼总共有 $f(n)$ 步时，其前一次选择可以有 $f(n-1)$ 和 $f(n-2)$ 步选择。可知总的方法如下公式所示：

$f(n)=f(n-1)+f(n-2)$

class Solution{
public:
    int climbStairs(int n){
        if(n==1){
            n=1;
        }
        if(n==2){
            n=2;
        }
        if(n>2){
            n = climbStairs(n-1) + climbStairs(n-2);
        }
        return n;
    }
};

上述代码直接采用斐波那契数列进行递归调用，当需要n阶台阶才能到达楼顶时，每次调用climbStairs函数时，执行里面的两个climbStairs，当调用n次时，需要执行2^N次climbStairs函数计算，因此时间复杂度为O(2^N)。而调用climbStairs函数需要占用N个空间，空间复杂度为O(N)。

解答二：

动态规划思想，转移方程和边界条件，滚动数组的思想把空间复杂度优化成O(1)，当到达第一个台阶最多有1种方法，到达第二个台阶总共有2种方法，到达第三个台阶总共有3种方法.......以此类推到达第四个台阶时，可分解为先到达第三个台阶，然后上一步，或者先到达第二个台阶，然后上两步。总结为 $f(n)=f(n-1)+f(n-2)$ ， $n$ 为到达的台阶阶数， $f(n-1)$ 为到达n-1个台阶时，总共有几种方法。

class Solution{
public:
    int climbStairs(int n){
        int a1=0,a2=0,a3=1;
        for(int i=1; i<=n; i++){
            a1 = a2;
            a2 = a3;
            a3 = a1+a2;
        }
        return a3;
    }
};

上述代码，时间复杂度为O(n), 空间复杂度为O(1)。相比解答一所采用数据结构，递归函数在执行时需要不断地调用自身，这会导致大量的函数调用栈，从而增加内存消耗和计算时间。相比之下，for循环通过迭代的方式执行，不需要额外的函数调用栈，因此通常具有较低的时间和空间复杂度。因此，在后续编程过程中，如果遇到类似递归函数的使用时，可以采用for循环代替之。

解答三：

由解答一和解答二不难看出，本问题即为快速求解递归函数 $f(n)=f(n-1)+f(n-2)$ 的策略问题，这里先补充一下数学知识：

如果一个递推函数形如 $f(n)=\sum _{i=1}^{m}{a_{i}}f(n-i)$ ，即齐次线性递推式时，我们可以把数列的递推关系转化成矩阵的递推关系。形如上述齐次线性递推式，可以构造出 $m\times m$ 的矩阵：

$\begin{bmatrix} a_{1} & a_{2} & a_{3} & ... &a_{m}\\ 1 & 0 & 0 & ... & 0\\ 0 & 1 & 0 & ... & 0\\ \vdots & \vdots & \vdots \\ 0 & 0 & 0 & ... & 1\\ \end{bmatrix}$

因此，原本递推函数 $f(n)=f(n-1)+f(n-2)$ 中 $a_{1}$ 为1， $a_{2}$ 为1。可以转化成矩阵的递推关系，转换成矩阵后的公式如下所示：

$\begin{bmatrix} f(n) \\ f(n-1) \\ \end{bmatrix}= \begin{bmatrix} 1 & 1 \\ 1 & 0 \\ \end{bmatrix} \begin{bmatrix} f(n-1) \\ f(n-2) \\ \end{bmatrix}$

则递推公式可以转换成矩阵M的n次幂快速相乘，从而求得 $f(n)$ 的值，其中 $M=\begin{bmatrix} 1 & 1 \\ 1 & 0 \\ \end{bmatrix}$ ，如果直接求取 $M^n$ ，得到 $f(n)$ ，时间复杂度是O(n)，因此我们可以定义矩阵乘法，然后利用快速幂算法来加速这里的 $M^n$ 求解。

class Solution {
public:
    vector<vector<long long>> multiply(vector<vector<long long>> &a, vector<vector<long long>> &b) {
        vector<vector<long long>> c(2, vector<long long>(2));
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j];
            }
        }
        return c;
    }

    vector<vector<long long>> matrixPow(vector<vector<long long>> a, int n) {
        vector<vector<long long>> ret = {{1, 0}, {0, 1}};
        while (n > 0) {
            if ((n & 1) == 1) {
                ret = multiply(ret, a);
            }
            n >>= 1;
            a = multiply(a, a);
        }
        return ret;
    }

    int climbStairs(int n) {
        vector<vector<long long>> ret = {{1, 1}, {1, 0}};
        vector<vector<long long>> res = matrixPow(ret, n);
        return res[0][0];
    }
};

其中，vector<vector<long long>> c(2, vector<long long>(2))，表示创建一个2*2的二维向量。初始值为默认值为0。

文章部分内容转载自链接：https://leetcode.cn/problems/climbing-stairs/solutions/286022/pa-lou-ti-by-leetcode-solution/