链接

https://leetcode-cn.com/problems/qing-wa-tiao-tai-jie-wen-ti-lcof/
难度： #简单

题目

一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

示例 1：

输入：n = 2
输出：2

示例 2：

输入：n = 7
输出：21

示例 3：

输入：n = 0
输出：1

提示：
0 <= n <= 100
注意：本题与主站 70 题相同：https://leetcode-cn.com/problems/climbing-stairs/

代码框架

class Solution {
    public int numWays(int n) {

    }
}

题目解析

解答思路1：
青蛙跳台阶问题,是一个最简单的动态规划问题，
经过分析，其本质为斐波那契数列,仅初始的数值有细微区别。
台阶数n可以用一个递推公式表达：
F(n)=F(n-1)+F(n-2)
F(0)=1，台阶数为0，跳法为1
F(1)=1，台阶数为1，跳法为1
F(2)=2，台阶数为2，跳法为2
当台阶数为3，可以分为两种情况：
如果第一步跳1个台阶，则剩下2个台阶，有F(2)种跳法
如果第一步跳2个台阶，则剩下1个台阶，有F(1)种跳法
所以F(3)=F(2)+F(1)
当台阶数为n，同样分为两种情况：
如果第一步跳1个台阶，则剩下n-1个台阶，有F(n-1)种跳法
如果第一步跳2个台阶，则剩下n-2个台阶，有F(n-2)种跳法
所以F(n)=F(n-1)+F(n-2)
下面使用迭代解法，
用备忘录缓存中间结果，
返回对应台阶n的跳法F(n)。

测试用例

package edu.yuwen.sowrd.num10_II.solution;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import edu.yuwen.sowrd.num10_II.sol1.Solution;

public class SolutionTest {

    /**示例 1：
     * 输入：n = 2
     * 输出：2
     */
    @Test
    public void testCase1() {
        Solution solution = new Solution();

        int res = solution.numWays(2);
        Assertions.assertEquals(2, res);
    }

    /**示例 2：
     * 输入：n = 7
     * 输出：21
     */
    @Test
    public void testCase2() {
        Solution solution = new Solution();

        int res = solution.numWays(7);
        Assertions.assertEquals(21, res);
    }

    /**示例 3：
     * 输入：n = 0
     * 输出：1
     */
    @Test
    public void testCase3() {
        Solution solution = new Solution();

        int res = solution.numWays(0);
        Assertions.assertEquals(1, res);
    }
}

解答1 推荐

package edu.yuwen.sowrd.num10_II.sol1;

public class Solution {
    private static final int MOD_NUM = 1000000007;

    int[] dp = null;

    public int numWays(int n) {
        if (n == 0) {
            return 1;
        }
        if (n == 1) {
            return 1;
        }
        dp = new int[n + 1];
        dp[0] = 1;
        dp[1] = 1;
        int i = 2;
        while (i < n + 1) {
            dp[i] = (dp[i - 1] + dp[i - 2]) % MOD_NUM;
            i++;
        }
        return dp[n];
    }
}