10- II. 青蛙跳臺階問題 鏈接 題目 代碼框架 題目解析 測試用例 解答1 推薦

鏈接

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];
    }
}