爬楼梯（递归、动态规划、矩阵）

LeetCode-爬楼梯

目录

LeetCode-爬楼梯

做法一：递归

 做法二：动态规划

做法三： 通项公式矩阵形式

---

做法一：递归

//leetcode 爬楼梯
//做法一：递归 分析可知，答案满足斐波那契数列的规律
int solution(int n){
        if(n==1) return 1; 
        if(n==2) return 2;  //他们俩的值被自己的上一级调用了，所以并不是最终返回的结果
        return solution(n-1)+solution(n-2); //最终返回的是这个值
}

int climbStairs(int n){
    int slu;
    slu=solution(n);
    return slu;
}

递归的过程中，总有重复递归的地方，以N=5为例，2被计算了2次，增大了时间复杂度

 为了减小时间复杂度，我们采用记忆递归法的方法

实现方法：

定义一个memo数组，用来记录每次计算的结果，当递归到第n个台阶时，如果我们已经计算过了，那我们直接返回memo里面的这个结果

代码实现如下：

//记忆递归法
目前不会写，先看看下面这个思路
等会写了再更新

 做法二：动态规划

代码实现：

int climbStairs(int n) {
    //一维动态规划
    if(n==1) return 1;
    if(n==2) return 2;
    int dp[n+1]; //需要多少空间就定义多少空间
    dp[0]=0;
    dp[1]=1;
    dp[2]=2;
    for(int i=3;i<=n;++i){
        dp[i]=dp[i-1]+dp[i-2];
    }
    return dp[n];
}

做法三： 通项公式矩阵形式

不是自己写的，等有能力了更新个简单的

struct Matrix {
    long long mat[2][2];
};

struct Matrix multiply(struct Matrix a, struct Matrix b) {
    struct Matrix c;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            c.mat[i][j] = a.mat[i][0] * b.mat[0][j] + a.mat[i][1] * b.mat[1][j];
        }
    }
    return c;
}

struct Matrix matrixPow(struct Matrix a, int n) {
    struct Matrix ret;
    ret.mat[0][0] = ret.mat[1][1] = 1;
    ret.mat[0][1] = ret.mat[1][0] = 0;
    while (n > 0) {
        if ((n & 1) == 1) {
            ret = multiply(ret, a);
        }
        n >>= 1;
        a = multiply(a, a);
    }
    return ret;
}

int climbStairs(int n) {
    struct Matrix ret;
    ret.mat[1][1] = 0;
    ret.mat[0][0] = ret.mat[0][1] = ret.mat[1][0] = 1;
    struct Matrix res = matrixPow(ret, n);
    return res.mat[0][0];
}