力扣 经典算法之爬楼梯_力扣爬楼梯

今天来用两种的方法解一道题

题目如下：

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

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

先分析题目吧，我觉得它在考我数学思维，

解数学题嘛，一步步来吧。

n=1：走1步，只能有1种解法
n=2：可以走1+1步，也可以直接走2步，2种解法
n=3：可以走的方式有：1+1+1，1+2，2+1，共3种
n=4：走法有1+1+1+1，1+2+1，2+1+1，1+1+2，2+2，共5种
n=5：走法有1+1+1+1+1，1+1+1+2，1+1+2+1，1+2+1+1，2+1+1+1，2+2+1，1+2+2，2+1+2，共8种

到这里有发现什么规律了吗？1，2，3，5，8......，从第3项开始，当前项的值就是前面两项的和，这其实是著名的斐波那契数列

也就是说当爬上n个台阶的时候，有两种方法：一是在n-1个台阶上爬一个台阶，二是在n-2个台阶上爬两个台阶，把n-1和n-2相加即为n。所以得到递推公式

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

也要注意递归边界 :n>=2,最后一次递归调用为 f(2) = f(1) + f(0)，边界就是 f(1) = 1，f(0) = 1。

方法一：递归求解

经过上面解释，这个很容易理解。

int f(int n)
{
    long s;
    if(n==1)
        s=1;
    else if(n==2)
        s=2;
    else
        s=f(n-1)+f(n-2);
    return s;
}

完整代码：

#include <stdio.h>
#include <stdlib.h>
int f(int n);
int main()
{
    int n,t;
    scanf("%d",&n);
    t=f(n);
    printf("%d",t);
    return 0;
}
int f(int n)
{
    long s;
    if(n==1)
        s=1;
    else if(n==2)
        s=2;
    else
        s=f(n-1)+f(n-2);
    return s;
}

方法二：动态规划

最初时间复杂度和空间复杂度都是O(n)。

用「滚动数组思想」把空间复杂度优化为O(1)。

浅浅介绍一下滚动数组吧，

滚动数组是DP中的一种编程思想。简单的理解就是让数组滚动起来，每次都使用固定的几个存储空间，来达到压缩，节省存储空间的作用。起到优化空间，主要应用在递推或动态规划中（如01背包问题）。因为DP题目是一个自底向上的扩展过程，我们常常需要用到的是连续的解，前面的解往往可以舍去。所以用滚动数组优化是很有效的。利用滚动数组的话在N很大的情况下可以达到压缩存储的作用。是用时间去换空间的

在斐波那契数列中

#include<bits/stdc++.h>
int main()
{
    int i;
    long long d[80];
    d[0]=1;
    d[1]=1;
    for(i=2;i<80;i++)
    {
        d[i]=d[i-1]+d[i-2];
    }
    printf("%lld\n",d[79]);
    return 0;
}

上面这个循环d[i]只依赖于前两个数据d[i - 1]和d[i - 2]; 为了节约空间用滚动数组的做法，可以将整个dp数组压缩成dp[3]

#include<bits/stdc++.h>
int main()
{
    int i;
    long long d[3];
    d[1]=1;
    d[2]=1;
    for(i=2;i<80;i++)
    {
        d[0]=d[1];
        d[1]=d[2];
        d[2]=d[0]+d[1]; 
    }
    printf("%lld\n",d[2]);
    return 0;
}

采用滚动数组的主要目的是压缩存储空间。

下面的代码中把空间复杂度优化为O(1)，进行实现。

int climbStairs(int n) {
    int p = 0, q = 0, r = 1;
    for (int i = 1; i <= n; ++i) {
        p = q;
        q = r;
        r = p + q;
    }
    return r;
}

复杂度分析

时间复杂度：循环执行 nn 次，每次花费常数的时间代价，故渐进时间复杂度为 O(n)O(n)。
空间复杂度：这里只用了常数个变量作为辅助空间，故渐进空间复杂度为 O(1)O(1)。

完整代码：

#include <stdio.h>
int climbStairs(int n) ;
int main()
{
	int n,t;
    scanf("%d",&n);
    t=climbStairs(n);
    printf("%d",t);
    return 0;
}
 
int climbStairs(int n) {
    int p = 0, q = 0, r = 1;
    for (int i = 1; i <= n; ++i) {
        p = q;
        q = r;
        r = p + q;
    }
    return r;
}

其实还有很多其他方法：矩阵快速幂、通项公式，大家如果感兴趣可以继续研究一下，ヾ(￣▽￣)Bye~Bye~