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

---

一、题目

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/qing-wa-tiao-tai-jie-wen-ti-lcof

二、动态规划：

1.思路

跳第n个台阶，只有两种跳法，一种是从第n-1层跳一层，一种是从第n-2层跳2层
即： $f(n)=f(n-1)+f(n-2)$
#不加2是因为，从n-1层只走一步，只有一种可能，从n-2直接到n，也只有一种可能。
（1）普通的递归法，和求斐波那契数列第 n 项的值类似，会有大量重复运算。
（2）新建一个长度为 n+1 的数组，用于在递归时存储 f(0) 至 f(n) 的数字值，重复遇到某数字时则直接从数组取用，避免了重复的递归计算。
（3）不使用数组，节省存储空间。

2.动态规划解析：

状态定义： 设 dp 为一维数组，其中 dp[i] 的值代表 青蛙跳第 i 阶台阶可能的跳法数量。
转移方程： dp[i + 1] = dp[i] + dp[i - 1]，即对应数列定义 f(n + 1) = f(n) + f(n - 1)；
初始状态： dp[0] = 1，dp[1]=1 ，即初始化前两个数字；
返回值： dp[n] ，即 青蛙跳第 n 阶台阶可能的跳法数量。

3.动归五部曲

公众号：代码随想录
https://mp.weixin.qq.com/s/ko0zLJplF7n_4TysnPOa_w

1.确定dp数组及下标含义

    dp[i]: 表示 爬到第 i 个台阶，总共的可能方法有 dp[i]个

2.确定递推公式

    当爬最后一层时，
    （1）从n-1层直接爬一阶到第n层
    （2）从第n-2层爬两层到第n层
    f(n)=f(n-1)+f(n-2)
    dp[i]=dp[i-1]+dp[i-2]

3.dp数组如何初始化

    dp[1]=1 
    dp[2]=2
    ======> dp[0]=1

4.确定遍历顺序

    从前向后遍历，从2 ---> n+1

5.举例推导dp数组

    dp[3]=dp[2]+dp[1]=3
    dp[4]=dp[3]+dp[2]=5
    dp[5]=dp[4]+dp[3]=8

4.具体代码

（1）使用记忆化数组

class Solution:
    def numWays(self, n: int) -> int:
        #动态规划
        #跳第n个台阶，只有两种跳法，一种是从第n-1层跳一层，一种是从第n-2层跳2层
        #f(n)=f(n-1)+f(n-2)
        #不加2是因为，从n-1层只走一步，只有一种可能，从n-2直接到n，也只有一种可能。
        
        #用数组将每层的跳法数存储
        nums=[0]*(n+1)
        #nums=list(0 for i in range(n+1))
        
        if n==0 or n==1:
            return 1
        nums[0]=1
        nums[1]=1
        # #nums[2]=2,nums[3]=3
        for i in range(2,n+1):
           nums[i]=nums[i-1]+nums[i-2]
        return nums[n] % 1000000007

记忆化存储的数组需要使用 O(N) 的额外空间。

（2）未使用数组

class Solution:
    def numWays(self, n: int) -> int:
        #动态规划
        
        #if n==0 or n==1:
         #   return 1  可不进行判断
        a=1 #第0个台阶
        b=1 #第1个台阶
       
        for i in range(n):#执行n次
          #i=0时，   a=b ：第1个台阶  b：第2个台阶
          #i=1时，   a：   第2阶台阶  b: 第3个台阶
          #i=n-1时， a:    第n个台阶  b：第n+1个台阶，返回a
          a,b=b,a+b
        return a%1000000007

时间复杂度 O(N) ： 计算 f(n)需循环 n次，每轮循环内计算操作使用 O(1)。
空间复杂度O(1) ： 几个标志变量使用常数大小的额外空间。

作者：jyd
链接：https://leetcode-cn.com/problems/qing-wa-tiao-tai-jie-wen-ti-lcof/solution/mian-shi-ti-10-ii-qing-wa-tiao-tai-jie-wen-ti-dong/
来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

三、62. 不同路径：

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/unique-paths
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1. 动归五部曲

(1) 数组含义及下标表示

    dp[i][j] :  表示从 点（0，0）出发，到 点（i，j）共有dp[i][j]条路径

(2) 确定递推公式

    dp[i][j]=dp[i-1][j]+dp[i][j-1]

(3) dp数组的初始化（!!!）

    dp[i][0]=1  #从（0，0）到(i,0)只有一条路径
    dp[0][j]=1  #从（0，0）到(0,j)也只有一条路径

(4) 确定遍历顺序

    从左到右一层一层遍历

(5) 举例推导dp数组

    dp[1,2]=dp[1,1]+dp[0,2]=dp[1,0]+dp[0,1]+dp[0,2]=3
    dp[2,1]=dp[2,0]+dp[1,1]=3
    
    dp[3][2]表示点（4，3）
    dp[3,2]=dp[2,2]+dp[3,1]
           =dp[1,2]+dp[2,1]+dp[3,0]+dp[2,1]
           =3+3+1+3=10

2. 具体代码

2.1 二维数组

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
       #将原始问题分解为子问题
       
        dp = [[0 for j in range(n)] for i in range(m)]
        for i in range(m):
            dp[i][0]=1
        for j in range(n):
            dp[0][j]=1
        for i in range(1,m):
            for j in range(1,n):
                dp[i][j]=dp[i-1][j]+dp[i][j-1]
        
        return dp[m-1][n-1]

用列表生成一个m行n列的全为0的二维数组

 dp = [[0 for j in range(n)] for i in range(m)]

2.2 一维数组

先遍历第0行中的各个元素

dp[0], dp[1],dp[2],dp[3] ......dp[6]

再遍历第1行中的各个元素
dp[0],
dp[1]=第0行的dp[1]+重新赋值后的dp[0]
dp[2]=第0行的dp[2]+重新赋值后的dp[1]
.......

上一层的第j个元素都被存储在 dp[n] 中
只维护一个dp[],一维n列，一行一行遍历，每次遍历完，dp[i]中都存放的是到当前行，第j个点不同路径的数目

 class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        #一维数组 存放每一行数据
        dp=list(0 for i in range(n))
        for i in range(n):
            dp[i]=1
        for i in range(1,m):  #遍历每一行
            for j in range(1,n):#遍历每一列
                dp[j]=dp[j]+dp[j-1]
        return dp[n-1]