目录
62. 不同路径
题目链接：link
1、题目描述
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
问总共有多少条不同的路径？
2、思路
动态规划
d
p
[
i
]
[
j
]
=
d
p
[
i
−
1
]
[
j
]
+
d
p
[
i
]
[
j
−
1
]
dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
dp[i][j]=dp[i−1][j]+dp[i][j−1]
3、code
class Solution:
def uniquePaths(self, m: int, n: int) -> int:
# 动态规划
if m == 1 or n == 1:
return 1
# step1:dp[i][j]表示从（0，0）到（i,j）有多少路径
dp = [[0]*n for _ in range(m)] # 创建一个m行n列的二维数组
# step2:递推公式：dp[i][j] = dp[i][j-1] + dp[i-1][j]
# step3:初始条件，第一行和第一列都是1
for j in range(n):
dp[0][j] = 1
for i in range(1,m):
dp[i][0] = 1
# step4:确认遍历顺序：先从左到右，再从上到下
for i in range(1,m):
for j in range(1,n):
dp[i][j] = dp[i][j-1] + dp[i-1][j]
return dp[m-1][n-1]
4、复杂度分析
1️⃣ 时间复杂度：
O
(
M
×
N
)
O(M \times N)
O(M×N)
2️⃣ 空间复杂度：
O
(
M
×
N
)
O(M \times N)
O(M×N)
5、二维数组语法（本菜鸡总是出错）
# 创建3行4列的二维数组
matrix = [[0 for _ in range(4)] for _ in range(3)]
# 获取第一行
first_row = matrix[0]
# 获取第一列
first_column = [row[0] for row in marix]
# 获取前两行和两列
sub_matrix = [row[0:2] for row in matix[0:2]]
# 获得行数
num_row = len(matrix)
# 获得列数
num_col = len(matrix[0])
63. 不同路径 II
题目链接：link
1、题目描述
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。
现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
网格中的障碍物和空位置分别用 1 和 0 来表示。
输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
输出：2
解释：3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：
- 向右 -> 向右 -> 向下 -> 向下
- 向下 -> 向下 -> 向右 -> 向右
2、思路
略（很好想）
3、code
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
# step1:dp[i][j]表示从（0，0）到（i,j）有多少路径
dp = [[0]*n for _ in range(m)] # 创建一个m行n列的二维数组
# step2:递推公式：如果（i,j）没有障碍物：dp[i][j] = dp[i][j-1] + dp[i-1][j]
# step3:初始条件，第一行和第一列都是1，但是当有障碍物出现在第一行或者第一列，后面的值都未0
for j in range(n): # 第一行
if obstacleGrid[0][j] == 0:
dp[0][j] = 1
else:
break
for i in range(1,m):
if obstacleGrid[i][0] == 0:
dp[i][0] = 1
else:
break
# step4:确认遍历顺序：先从左到右，再从上到下
for i in range(1,m):
for j in range(1,n):
if obstacleGrid[i][j] == 0:
dp[i][j] = dp[i][j-1] + dp[i-1][j]
return dp[m-1][n-1]
4、复杂度分析
1️⃣ 时间复杂度：
O
(
M
×
N
)
O(M \times N)
O(M×N)
2️⃣ 空间复杂度：
O
(
M
×
N
)
O(M \times N)
O(M×N)
343. 整数拆分
题目链接：link
1、题目描述
给定一个正整数 n ，将其拆分为 k 个 正整数 的和（ k >= 2 ），并使这些整数的乘积最大化。
返回 你可以获得的最大乘积 。
2、思路
❓思考逻辑：求n的拆分乘积最大值？最简单的就是拆分成两个数
i
i
i 和
(
n
−
i
)
(n-i)
(n−i) 的乘积最大值，但是由于可以拆成更多的数，所以结果应该是拆分项
i
i
i 和
(
n
−
i
)
(n-i)
(n−i) 的拆分乘积最大值，这里其实就说明我们需要更小的整数拆分结果来得到n的整数拆分结果，使用动态规划可以存储子问题（更小整数拆分结果）
dp[i]：分拆数字i，可以得到的最大乘积为dp[i]。
d
p
[
i
]
=
m
a
x
(
d
p
[
i
]
,
(
i
−
j
)
∗
j
,
d
p
[
i
−
j
]
∗
j
)
dp[i] = max({dp[i], (i - j) * j, dp[i - j] * j})
dp[i]=max(dp[i],(i−j)∗j,dp[i−j]∗j)
3、code
class Solution:
def integerBreak(self, n: int) -> int:
# 动态规划
# 判断特殊情况
if n == 0 or n == 1:
return 0
# step1:dp[i]代表对i拆分能获得的最大乘积
dp = [0] * (n+1)
# step2:递推公式：dp[i] = max(j * (i-j),j*dp[i-j],dp[i])
# step3:初始化
dp[0] = 0
dp[1] = 0
dp[2] = 1
# step4:确定循环顺序
for i in range(3,n+1):
for j in range(1,i//2 + 1):
dp[i] = max(j * (i-j),j*dp[i-j],dp[i])
return dp[n]
4、复杂度分析
1️⃣ 时间复杂度：
O
(
N
2
)
O(N^2)
O(N2)
2️⃣ 空间复杂度：
O
(
N
)
O(N)
O(N)
96. 不同的二叉搜索树
题目链接：link
0、 二叉搜索树
二叉搜索树是一个有序树:对节点的布局没有要求，但是要求节点的数值
- 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
- 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
- 它的左、右子树也分别为二叉搜索树
1、题目描述
给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。
示例 1：
输入：n = 3
输出：5
2、思路
遍历举例：
（简略图，有时间画清晰版）
dp[i] ： 1到i为节点组成的二叉搜索树的个数为dp[i]。
3、code
class Solution:
def numTrees(self, n: int) -> int:
if n == 1:
return 1
if n == 2:
return 2
dp = [0] * (n+1)
dp[0] = 1
dp[1] = 1
dp[2] = 2
for i in range(3,n+1):
# 一共i个节点
for j in range(1,i+1):
# 头节点的元素为j，左子树节点数量有（j-1），右子树节点数量有(i-j)
dp[i] += dp[j-1] * dp[i-j]
return dp[n]
4、复杂度分析
1️⃣ 时间复杂度：
O
(
N
2
)
O(N ^ 2)
O(N2)
2️⃣ 空间复杂度：
O
(
N
)
O(N)
O(N)
871
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
