“爬楼梯”或斐波那契数列的几种解法浅析~~C++实现

关山煮酒

已于 2023-01-29 21:39:11 修改

阅读量554

点赞数 1

分类专栏： C++算法文章标签： c++ 算法 leetcode

于 2023-01-27 14:09:35 首次发布

本文链接：https://blog.csdn.net/weixin_50923989/article/details/128770101

版权

C++算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本题的实现方法有很多,本文浅浅列出几种~~

思路1：暴力递归

思路

利用递推公式f(n) = f(n-1)+f(n-2)来编写代码

代码实现

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

效果

超出时间限制，在输入为44的时候超时。
原因：时间复杂度是O（2^n），指数级时间复杂度是灾难的

对于思路一，我们在计算的时候做了很多多余的事情，比如算f(n-1)+f(n-2)的过程中，计算f(n-1)的时候还要算一次f（n-2）,这就要多递归一次，浪费了很多的时间

思路2：空间换时间

思路

用一个向量保存斐波那契数列，减少了递归的时间

代码实现

class Solution {
public:
    vector<int> ans;
    int climbStairs(int n) {
        if(n == 0) return 0;   
        ans.push_back(0);
        ans.push_back(1);
        ans.push_back(2);
        for(int i = 3; i <= n; ++i)
        {
            ans.push_back(ans[i-2]+ans[i-1]);
        }
        return ans[n];
    }
};

效果

渐进时间复杂度是O（n），空间复杂度是O（n)
执行用时：0 ms, 在所有 C++ 提交中击败了100.00%的用户
内存消耗：6 MB, 在所有 C++ 提交中击败了36.43%的用户

有没有办法降低空间复杂度呢？接着看如下：

思路3：滚动数组

思路

如下图所示的三块砖移步比赛所示，滚动数组就是类似的原理，只需要3个变量就可以完成斐波那契数列的递归运算
{:width=400}

代码实现

class Solution {
 public:
    vector<int> ans;
    int climbStairs(int n) {   
        if(n == 1) return 1;
        if(n == 2) return 2;
        int p=1,q=2,r = 0;
        for(int i = 3; i<=n ; ++i) //直接从3级阶梯开始
        {
            r = p+q;
            p = q;
            q = r;
        }
        return r;
    }
};

效果

执行用时：0 ms, 在所有 C++ 提交中击败了100.00%的用户
内存消耗：5.7 MB, 在所有 C++ 提交中击败了89.07%的用户
时间复杂度还是O（n），但空间复杂度已经变成了O（1）

思路:4：递推公式

思路

众所周知，斐波那契数列是有通项公式的，可以凭借高中数学中数列有关的不动点去进行计算，这里直接给出：

代码实现

class Solution {
 public:
    vector<int> ans;
    int climbStairs(int n) {   
    double sqrt5 = sqrt(5);
    double fn = pow((1 + sqrt5) / 2, n + 1) - pow((1 - sqrt5) / 2, n + 1);
        return (int)(fn / sqrt5);

    }
};

效果

执行用时：0 ms, 在所有 C++ 提交中击败了100.00%的用户
内存消耗：6 MB, 在所有 C++ 提交中击败了33.96%的用户
复杂度不做讨论

思路5：矩阵快速幂

思路

可以将计算过程看成如下的矩阵乘法：

只需要能快速计算图中矩阵的n次幂即可快速得到答案。
这里矩阵快速幂就是用类似二分的思想

代码实现

class Solution {
public:
    //4*4矩阵乘法
    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) //用来判断奇数还是偶数，如果是奇数
            {
                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];
    }
};