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

题目

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

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

示例 1：

输入：n = 2
输出：2
示例 2：

输入：n = 7
输出：21
示例 3：

输入：n = 0
输出：1
提示：

0 <= n <= 100

思路

寻找之间的关系：

n=1 输出：1 

1
{1}

n=2 输出：2

1
2
最后一次跳了一阶台阶{1，1}
最后一次跳了两阶台阶{2}

n=3 输出：3

1
2
最后一次跳了一阶台阶{1，1，1}，{2,1}
最后一次跳了两阶台阶{1,2}

n=4 输出：5

1
2
最后一次跳了一阶台阶{1，1，1，1}，{2,1,1}，{1,2，1}
最后一次跳了两阶台阶{1,1,2}，{2,2}

用数学思想推导：

最后一次跳了一阶台阶，这类方法一共有f（n-1）种；

最后一次跳了两阶台阶，这类方法一共有f（n-2）

可以推出来:

1
2
n阶台阶的次数 = 最后一次跳了一阶台阶 + 最后一次跳了两阶台阶
f(n)=f(n−1)+f(n−2)

实现

记忆化递归法

看到这样的题目首先想到了汉诺塔问题和斐波那契数列，递归实现

和斐波那契数列的记忆化递归类似，主要就是求出推到公式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
private static class Solution {
        public int numWays(int n) {
            if (n < 2) {
                return 1;
            }
            int[] memorization = new int[n + 1];
            memorization[0] = 1;
            memorization[1] = 1;
            return numWays(n, memorization);
        }

        private static int numWays(int n, int[] memorization) {
            if (n < 2 || memorization[n] > 0) {
                return memorization[n];
            }
            memorization[n] = (numWays(n - 1, memorization) + numWays(n - 2, memorization)) % 1000000007;
            return memorization[n];
        }
    }

动态规划

不从f（n）开始，而是从f（1）和f（2）开始，逐渐累加

1
f(n + 1) = f(n) + f(n - 1)
1
2
3
4
5
6
7
8
9
10
11
private static class Solution { 
    public int numWays(int n) {
         int a = 1, b = 1, sum ;
         for (int i = 0; i < n; i++) {
             sum = (a + b)  % 1000000007;
             a = b;
             b = sum;
         }
         return a;
     }
 }

博客首先发布于：

https://lvxiaoyi.top/