代码随想录算法训练营第38、39天 | 509. 斐波那契数 70. 爬楼梯 746. 使用最小花费爬楼梯 62.不同路径 63. 不同路径 II

代码随想录系列文章目录

动态规划篇 - 基础

---

---

前言

如果某一问题有很多重叠子问题，使用动规是有效的。所以动态规划中每一个状态一定是由上一个状态推导出来的。

这就决定了dp的解题思路：状态定义， 状态转移， 初始化base case， 确定遍历顺序, 确定解的位置

分别拆开解释，拆解为如下五步曲：

确定dp数组（dp table）以及下标的含义
确定递推公式
dp数组如何初始化
确定遍历顺序
举例推导dp数组

其中，dp的递推公式决定了 base case, 也决定了遍历顺序

debug的话也很简单，就是打印dp数组，看看是否和自己推导的是一样的

---

509.斐波那契数

最简单的dp

def fib(self, n: int) -> int:
        if n < 2: return n
        dp = [0] * (n+1)
        dp[1] = 1
        for i in range(2, n+1):
            dp[i] = dp[i-1]+dp[i-2]
        return dp[n]

70.爬楼梯

题目链接
写的时候脑子抽抽了，dp[n] = dp[n-1]+dp[n-2]起来了

def climbStairs(self, n: int) -> int:
        dp = [1] * (n+1)
        for i in range(2, n+1):
            dp[i] = dp[i-1]+dp[i-2]
        return dp[n]

这道题目还可以继续深化，就是一步一个台阶，两个台阶，三个台阶，直到 m个台阶，有多少种方法爬到n阶楼顶。
这其实是一个完全背包问题，代码中m表示最多可以爬m个台阶

class Solution {
public:
    int climbStairs(int n) {
        vector<int> dp(n + 1, 0);
        dp[0] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) { // 把m换成2，就可以AC爬楼梯这道题
                if (i - j >= 0) dp[i] += dp[i - j];
            }
        }
        return dp[n];
    }
};

以上代码不能运行，因为m没确定，但是代表一种思路
下面引用代码随想录：

此时我就发现一个绝佳的大厂面试题，第一道题就是单纯的爬楼梯，然后看候选人的代码实现，如果把dp[0]的定义成1了，就可以发难了，为什么dp[0]一定要初始化为1，此时可能候选人就要强行给dp[0]应该是1找各种理由。那这就是一个考察点了，对dp[i]的定义理解的不深入。

然后可以继续发难，如果一步一个台阶，两个台阶，三个台阶，直到 m个台阶，有多少种方法爬到n阶楼顶。这道题目leetcode上并没有原题，绝对是考察候选人算法能力的绝佳好题。

这一连套问下来，候选人算法能力如何，面试官心里就有数了。

其实大厂面试最喜欢问题的就是这种简单题，然后慢慢变化，在小细节上考察候选人。
通过求x的n次方了解递归的复杂度

746.使用最小花费爬楼梯（很好的题）

题目链接
这个题就没那么简单，

难点是状态定义 dp[i], 代表到达下标为i的台阶需要的最小花费，每当你爬上一个阶梯你都要花费对应的体力值, 到达i就要支付cost[i]

第二,状态转移，我要达到i，可以到达i-1 i-2, 我选一个成本低的，注意题目中每当你爬上一个阶梯你都要花费对应的体力值， 所以dp[i] = min(dp[i-1],dp[i-2])+cost[i]

第三，想清楚下标问题了，就明白数组和最终解的位置了，我们只用走到i-2, i-1下标的位置，就能到终点，所以dp数组应该开成n,和cost数组一样大小

#状态定义 dp[i] 到达第i个台阶需要的最小花费
#状态转移 dp[i] = min(dp[i-1],dp[i-2])+cost[i]
#base case dp[0],dp[1] = cost[0],cost[1]
#遍历顺序，正序
#最终解的位置，由于我们状态定义是到达i就算cost[i], 我们只用到i-1/i-2, dp数组长n就行
class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        n = len(cost)
        dp = [0]* (n)
        dp[0] = cost[0]
        dp[1] = cost[1]
        for i in range(2,n):
            dp[i] = min(dp[i-1],dp[i-2])+cost[i]
        return min(dp[n-1],dp[n-2])

写dp章节应该多去思考，理解透

62.不同路径

题目链接

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        dp = [[1]*(n) for _ in range(m)]
        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列的dp数组去填了，初始化为1，然后从第二行第二列开始填，最后解在右下角位置

63. 不同路径 II

题目链接

dp代码

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        m,n = len(obstacleGrid), len(obstacleGrid[0])
        if obstacleGrid[0][0] == 1 or obstacleGrid[m-1][n-1]: return 0
        dp = [[0]*(n+1) for _ in range(m+1)]
        for i in range(1,n+1):
            if obstacleGrid[0][i-1] != 1: dp[1][i] = 1
            else: break
        for j in range(1,m+1):
            if obstacleGrid[j-1][0] != 1: dp[j][1] = 1
            else: break
        for i in range(2,m+1):
            for j in range(2,n+1):
                if obstacleGrid[i-1][j-1] == 1: continue
                elif obstacleGrid[i-2][j-1] == 1: dp[i][j] = dp[i][j-1]
                elif obstacleGrid[i-1][j-2] == 1: dp[i][j] = dp[i-1][j]
                else: dp[i][j] = dp[i-1][j]+dp[i][j-1]
        return dp[m][n]

其实填的时候不用想的那么细，如果说遇到1，我们直接跳过，它天然是0
我们直接可以这样填

for i in range(2,m+1):
    for j in range(2,n+1):
        if obstacleGrid[i-1][j-1] == 1: continue
        else: dp[i][j] = dp[i-1][j]+dp[i][j-1]
return dp[m][n]

dfs代码

再保留一下dfs递归写的代码，递归比较抽象，有点不好理解

 def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        m = len(obstacleGrid)
        n = len(obstacleGrid[0])
        if obstacleGrid[0][0] == 1 or obstacleGrid[m-1][n-1] == 1: return 0
        @lru_cache(None)
        def dfs(i, j):
            if i == m - 1 and j == n - 1:
                if obstacleGrid[i][j] == 0: 
                 return 1
            r = d = 0
            if i + 1 < m:
                if obstacleGrid[i + 1][j] == 0:
                    r = dfs(i + 1, j)
            if j + 1 < n:
                if obstacleGrid[i][j + 1] == 0:
                    d = dfs(i, j + 1)
            return r + d

        return dfs(0, 0)

我第一次面试暑期实习，网易就给我了一道这种题，我当时写的代码就是用递归写的
如果让写路径就不用返回值，如果让写有几种方式到就有返回值，这就是这种题的做法