剑指 Offer 10- II. 青蛙跳台阶问题

Posted 2021-05-16 是七喜呀！

青蛙跳台阶问题

• 有关题目
• • 题解

题目链接： 青蛙跳台阶问题

有关题目

一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。
求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

示例 1：

输入：n = 2
输出：2

示例 2：

输入：n = 7
输出：21

示例 3：

输入：n = 0
输出：1

提示：

0 <= n <= 100

题解

1、递归

class Solution {
public:
    int numWays(int n) {
        if (n == 0 || n == 1)
            return 1;
        else
            return (numWays(n - 1) + numWays(n - 2)) % 1000000007;
    }
};

多次重复计算一些值，例如：numWay(n - 2)、num(n - 3)、等等所以到n = 43就超时了。而下面的两种方法就没这重复计算的步骤。

2、哈希表
参考链接：坚持

class Solution {
public:
    unordered_map<int,int> mp;
    int dfs(int n)
    {
        if (n == 1 || n == 0)
            return 1;
        else if (mp.count(n))检查，这个n是不是之前就算过，如果算过直接返回，
            return mp[n];

        int a = dfs(n - 1) % 1000000007;//这步和下面一步都在回调函数，算出所需要的值
            mp[n - 1] = a;
        int b = dfs(n - 2) % 1000000007;
            mp[n - 2] = b;
        mp[n] = (a + b) % 1000000007;
        return mp[n] ;
    }
    int numWays(int n) {
      return dfs(n);
    }
};

3、记忆化递归法(迭代方法)
参考链接：Krahets

代码一：

class Solution {
public:
    int numWays(int n) {
        if (n < 2)
            return 1;//这边
        vector<int> dp(n + 1);
        dp[0] = 1,dp[1] = 1;
        for (int i = 1; i < n; i++)
        {
            dp[i + 1] = (dp[i] + dp [i - 1]) % 1000000007;
        }
         return dp[n] ;
    }
};

class Solution {
public:
    int numWays(int n) {
       vector<int> dp;//这边为啥加上(n + 1,0)，就跑不过去了？？？
       for (int i = 0; i <= n; i++)
        {
            if (i == 1 || i == 0)
                dp.push_back(1);
            else
                dp.push_back((dp[i - 1] + dp[i - 2]) % 1000000007 );
        }
        return dp[n];
    }
};

时间复杂度：O(n)
空间复杂度：O(n)

4、动态规划

int numWays(int n){
    if (n < 2)
            return 1;//这边在C++版本有可能跑不过去
        int first = 1,second = 1;
        for (int i = 2; i <= n; i++)
        {
            int tmp = second;
            second = (first + second) % 1000000007;
            first = tmp;
        }
        return second;
}

时间复杂度：O(n)
空间复杂度：O(1)