文章目录
- 1.动态规划理论基础
- 2.斐波那契数
- 3.爬楼梯
- 4.使用最小花费爬楼梯
- 5.不同路径
- [6.不同路径 II](#6.不同路径 II)
- [7. 整数拆分](#7. 整数拆分)
- [8. 不同的二叉搜索树](#8. 不同的二叉搜索树)
1.动态规划理论基础
1.1 什么是动态规划?
动态规划,英文:Dynamic Programming,简称DP,如果某一问题有很多重叠子问题,使用动态规划是最有效的。所以动态规划中每一个状态一定是由上一个状态推导出来的,这一点就区分于贪心,贪心没有状态推导,而是从局部直接选最优的。
1.2 动态规划的解题步骤
动态规划五部曲:
- 确定dp数组(dp table)以及下标的含义
- 确定递推公式
- dp数组如何初始化
- 确定遍历顺序
- 举例推导dp数组
2.斐波那契数
题目:
思路:
状态转移方程 dp[i] = dp[i - 1] + dp[i - 2]
代码:
python
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]
3.爬楼梯
题目:
思路:
递推公式dp[i] = dp[i - 1] + dp[i - 2]
代码:
python
class Solution:
def climbStairs(self, n: int) -> int:
if n == 1:return 1
if n == 2:return 2
dp = [0] * (n + 1)
dp[1] = 1
dp[2] = 2
for i in range(3,n+1):
dp[i] = dp[i - 2] + dp[i-1]
return dp[n]
4.使用最小花费爬楼梯
题目:
思路:
dp[i]的定义:到达第i台阶所花费的最少体力为dp[i]。
递推公式:
dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])
注:楼顶的下标是n+1
代码:
python
class Solution:
def minCostClimbingStairs(self, cost: List[int]) -> int:
dp = [0] * (len(cost) + 1)
# dp[0] = 0 # 初始值,表示从起点开始不需要花费体力
# dp[1] = 0 # 初始值,表示经过第一步不需要花费体力
for i in range(2, len(cost) + 1):
# 在第i步,可以选择从前一步(i-1)花费体力到达当前步,或者从前两步(i-2)花费体力到达当前步
# 选择其中花费体力较小的路径,加上当前步的花费,更新dp数组
dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])
return dp[len(cost)] # 返回到达楼顶的最小花费
5.不同路径
题目:
思路:
dp[i][j] :表示从(0 ,0)出发,到(i, j) 有dp[i][j]条不同的路径。
递推公式:dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
如何初始化呢,首先dp[i][0]一定都是1,因为从(0, 0)的位置到(i, 0)的路径只有一条,那么dp[0][j]也同理。
代码:
python
class Solution:
def uniquePaths(self, m: int, n: int) -> int:
# 创建一个二维列表用于存储唯一路径数
dp = [[0] * n for _ 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]
6.不同路径 II
题目:
思路:
【注】边界初始化时要注意障碍物,还要考虑到起始点和终止点的障碍物
当网格中没有障碍物时,执行递推公式。
代码:
python
class Solution:
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
dp = [[0] * n for _ in range(m)]
i = 0
j = 0
while i < m and obstacleGrid[i][0] != 1:
dp[i][0] = 1
i += 1
while j < n and obstacleGrid[0][j] != 1:
dp[0][j] = 1
j += 1
for i in range(1,m):
for j in range(1,n):
if obstacleGrid[i][j] != 1:
dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
return dp[m-1][n-1]
7. 整数拆分
题目:
思路:
dp[i]:分拆数字i,可以得到的最大乘积为dp[i]
递推公式:dp[i] = max({dp[i], (i - j) * j, dp[i - j] * j});
代码:
python
class Solution:
def integerBreak(self, n: int) -> int:
dp = [0] * (n + 1)
for i in range(2,n+1):
j = 1
while j <= i // 2:
dp[i] = max(j * (i - j),j*dp[i - j],dp[i])
j += 1
return dp[n]
8. 不同的二叉搜索树
题目:
思路:
思路详解
代码:
python
class Solution:
def numTrees(self, n: int) -> int:
dp = [0] * (n + 1) # 创建一个长度为n+1的数组,初始化为0
dp[0] = 1 # 当n为0时,只有一种情况,即空树,所以dp[0] = 1
for i in range(1, n + 1): # 遍历从1到n的每个数字
for j in range(1, i + 1): # 对于每个数字i,计算以i为根节点的二叉搜索树的数量
dp[i] += dp[j - 1] * dp[i - j] # 利用动态规划的思想,累加左子树和右子树的组合数量
return dp[n] # 返回以1到n为节点的二叉搜索树的总数量