五部曲
- 确定dp数组以及下标的含义
- 确定递推公式/状态转移公式
- dp数组如何初始化
- 确定遍历顺序
- 举例推导dp数组
Debug方法:
把dp数组打印出来,哪里有问题一目了然!
斐波那契数列
- 确定dp数组以及下标的含义
dp[i]的定义为:第i个数的斐波那契数值是dp[i] - 确定递推公式/状态转移公式
状态转移方程 dp[i] = dp[i - 1] + dp[i - 2]; - dp数组如何初始化
dp[0] = 0;
dp[1] = 1; - 确定遍历顺序
从递归公式dp[i] = dp[i - 1] + dp[i - 2];中可以看出,dp[i]是依赖 dp[i - 1] 和 dp[i - 2],那么遍历的顺序一定是从前到后遍历的 - 举例推导dp数组
按照这个递推公式dp[i] = dp[i - 1] + dp[i - 2],我们来推导一下,当N为10的时候,dp数组应该是如下的数列:
0 1 1 2 3 5 8 13 21 34 55
class Solution:
def fib(self, n: int) -> int:
# 排除 Corner Case
if n == 0:
return 0
# 创建 dp table
dp = [0] * (n + 1)
# 初始化 dp 数组
dp[0] = 0
dp[1] = 1
# 遍历顺序: 由前向后。因为后面要用到前面的状态
for i in range(2, n + 1):
# 确定递归公式/状态转移公式
dp[i] = dp[i - 1] + dp[i - 2]
# 返回答案
return dp[n]
爬楼梯
- 确定dp数组以及下标的含义
dp[i]: 爬到第i层楼梯,有dp[i]种方法 - 确定递推公式
首先是dp[i - 1],上i-1层楼梯,有dp[i - 1]种方法,那么再一步跳一个台阶不就是dp[i]了么。
还有就是dp[i - 2],上i-2层楼梯,有dp[i - 2]种方法,那么再一步跳两个台阶不就是dp[i]了么。
那么dp[i]就是 dp[i - 1]与dp[i - 2]之和!
所以dp[i] = dp[i - 1] + dp[i - 2] 。 - dp数组如何初始化
不考虑dp[0]如何初始化,只初始化dp[1] = 1,dp[2] = 2,然后从i = 3开始递推,这样才符合dp[i]的定义。 - 确定遍历顺序
从递推公式dp[i] = dp[i - 1] + dp[i - 2];中可以看出,遍历顺序一定是从前向后遍历的 - 举例推导dp数组
# 空间复杂度为O(n)版本
class Solution:
def climbStairs(self, n: int) -> int:
if n == 0:
return 0
if n == 1: # 会发现写完其他调试1时出错,因此检查代码,修改
return 1
dp = [0] * (n+1)
dp[1] = 1
dp[2] = 2
for i in range(3, n+1):
dp[i] = dp[i-1] + dp[i-2]
return dp[n]
# 空间复杂度为O(1)版本
class Solution:
def climbStairs(self, n: int) -> int:
if n == 0:
return 0
if n == 1: # 会发现写完其他调试1时出错,因此检查代码,修改
return 1
dp = [0] * (n+1)
dp[1] = 1
dp[2] = 2
for i in range(3, n+1):
tmp = dp[1] + dp[2]
dp[i] = tmp
dp[1] = dp[2]
dp[2] = tmp
return dp[n]
使用最小花费爬楼梯
- 确定dp数组以及下标的含义
dp[i]的定义:到达第i台阶所花费的最少体力为dp[i]。 - 确定递推公式
可以有两个途径得到dp[i],一个是dp[i-1] 一个是dp[i-2]。
dp[i - 1] 跳到 dp[i] 需要花费 dp[i - 1] + cost[i - 1]。
dp[i - 2] 跳到 dp[i] 需要花费 dp[i - 2] + cost[i - 2]。
那么究竟是选从dp[i - 1]跳还是从dp[i - 2]跳呢?
一定是选最小的,所以dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]); - dp数组如何初始化
看一下递归公式,dp[i]由dp[i - 1],dp[i - 2]推出,既然初始化所有的dp[i]是不可能的,那么只初始化dp[0]和dp[1]就够了,其他的最终都是dp[0]dp[1]推出。
初始化 dp[0] = 0,dp[1] = 0; - 确定遍历顺序
因为是模拟台阶,而且dp[i]由dp[i-1]dp[i-2]推出,所以是从前到后遍历cost数组就可以了。 - 举例推导dp数组
class Solution:
def minCostClimbingStairs(self, cost: List[int]) -> int:
if len(cost) <= 1: # 长度小于1,则顶楼小于2,可以一步搞定
return 0
dp = [0] * (len(cost)+1)
dp[0] = 0 # 上第1个台阶的费用
dp[1] = 0 # 上第2个台阶的费用
# 上第n个台阶的费用
for i in range(2, len(cost)+1):
dp[i] = min( (dp[i-1]+cost[i-1]), (dp[i-2]+cost[i-2]) )
return dp[len(cost)]