动归5步法
1,确定dp数组(dp table)以及下标的含义
2,确定递推公式
3,dp数组如何初始化
4,确定遍历顺序
5,举例推导dp数组
62不同路径
题目描述:
一个机器人位于一个 m x n
网格的左上角 (起始点在下图中标记为 “Start” )。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角(在下图中标记为 “Finish” )。
问总共有多少条不同的路径?
示例 1:
输入:m = 3, n = 7 输出:28
示例 2:
输入:m = 3, n = 2 输出:3 解释: 从左上角开始,总共有 3 条路径可以到达右下角。 1. 向右 -> 向下 -> 向下 2. 向下 -> 向下 -> 向右 3. 向下 -> 向右 -> 向下
代码:
class Solution {
public:
int uniquePaths(int m, int n) {
// 创建一个 m x n 的二维向量 dp,用于存储每个位置到达的路径数
vector<vector<int>> dp(m, vector<int>(n, 0));
// 初始化第一行,只有一条路径可以到达
for(int i = 0; i < n; i++) {
dp[0][i] = 1; // 第一行的每个位置都可以从左侧到达
}
// 初始化第一列,只有一条路径可以到达
for(int i = 0; i < m; i++) {
dp[i][0] = 1; // 第一列的每个位置都可以从上方到达
}
// 从第 1 行和第 1 列开始填充剩余的 dp 数组
for(int i = 1; i < m; i++) {
for(int j = 1; j < n; j++) {
// 当前单元格的路径数等于上方单元格和左侧单元格路径数之和
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
}
// 最终结果位于右下角
return dp[m - 1][n - 1];
}
};
按照动归5步法来做
1. 确定dp数组(dp table)以及下标的含义
- dp数组的定义:
dp[i][j]
表示从起点(0, 0)
到达位置(i, j)
的不同路径数量。 - 下标的含义:
i
和j
分别表示当前在网格中的行和列。
2. 确定递推公式
- 递推公式:对于任何位置
(i, j)
,它的路径数可以通过其上方位置(i-1, j)
和左侧位置(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. dp数组如何初始化
- 初始化第一行:对于第一行位置
dp[0][j]
,由于只能从左向右移动,因此每个位置都有且仅有一条路径,所以初始化为在1
。 - 初始化第一列:对于第一列位置
dp[i][0]
,由于只能从上向下移动,因此每个位置都有且仅有一条路径,所以初始化为为1
。
4. 确定遍历顺序
- 遍历顺序:从DP初始化的角度来看,首先初始化第一行和第一列。再从位置
(1,1)
开始,自顶向下(行优先)逐行遍历,且每行从左到右(列优先)遍历。
5. 举例推导dp数组
假设有一个 3 x 3
的网格(即 m = 3
, n = 3
),我们来推导DP数组的值。
初始化阶段:
-
初始化
dp[0][j]
为1
:dp = [[1, 1, 1], [0, 0, 0], [0, 0, 0]]
-
初始化
dp[i][0]
为1
:dp = [[1, 1, 1], [1, 0, 0], [1, 0, 0]]
递推计算阶段:
- 计算
dp[1][1]
:
dp[1][1]=dp[0][1]+dp[1][0]=1+1=2dp[1][1]=dp[0][1]+dp[1][0]=1+1=2
dp = [[1, 1, 1], [1, 2, 0], [1, 0, 0]]
- 计算
dp[1][2]
:
dp[1][2]=dp[0][2]+dp[1][1]=1+2=3dp[1][2]=dp[0][2]+dp[1][1]=1+2=3
dp = [[1, 1, 1], [1, 2, 3], [1, 0, 0]]
- 计算
dp[2][1]
:
dp[2][1]=dp[1][1]+dp[2][0]=2+1=3dp[2][1]=dp[1][1]+dp[2][0]=2+1=3
dp = [[1, 1, 1], [1, 2, 3], [1, 3, 0]]
- 计算
dp[2][2]
:
dp[2][2]=dp[1][2]+dp[2][1]=3+3=6dp[2][2]=dp[1][2]+dp[2][1]=3+3=6
dp = [[1, 1, 1], [1, 2, 3], [1, 3, 6]]
通过上述步骤,最终得到 3 x 3
网格的不同路径总数为 6
,存储在 dp[2][2]
中。
63不同路径
题目描述:
一个机器人位于一个 m x n
网格的左上角 (起始点在下图中标记为 “Start” )。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角(在下图中标记为 “Finish”)。
现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径?
网格中的障碍物和空位置分别用 1
和 0
来表示。
示例 1:
输入:obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
输出:2
解释:3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2
条不同的路径:
1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右
示例 2:
输入:obstacleGrid = [[0,1],[0,0]] 输出:1
代码:
class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid)
{
int m = obstacleGrid.size();
int n = obstacleGrid[0].size();
if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1) //如果在起点或终点出现了障碍,直接返回0
return 0;
vector<vector<int>> dp(m, vector<int>(n, 0));
for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) dp[i][0] = 1;
for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1;
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
if (obstacleGrid[i][j] == 1) continue;
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
}
return dp[m - 1][n - 1];
}
};
343整数拆分
题目描述:
给定一个正整数 n
,将其拆分为 k
个 正整数 的和( k >= 2
),并使这些整数的乘积最大化。
返回 你可以获得的最大乘积 。
示例 1:
输入: n = 2 输出: 1 解释: 2 = 1 + 1, 1 × 1 = 1。
示例 2:
输入: n = 10 输出: 36 解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。
代码;
class Solution {
public:
int integerBreak(int n) {
// 1. 定义dp数组,dp[i]表示将正整数i拆分后的最大乘积
vector<int> dp(n + 1, 0);
// 3. 初始化dp数组
dp[2] = 1; // 当i为2时,dp[2] = 1
// 4. 开始递推计算dp数组
for (int i = 3; i <= n; ++i) {
// 枚举所有可能的拆分点j
for (int j = 1; j < i; ++j) {
// 2. 应用递推公式:dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]))
dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]));
}
}
// 返回将正整数n拆分后的最大乘积
return dp[n];
}
};
1. 确定dp数组(dp table)以及下标的含义
- dp数组的定义:定义一个一维数组
dp
,其中dp[i]
表示将正整数i
拆分成至少两个正整数和之后,这些正整数的最大乘积。 - 下标的含义:
i
表示正整数的当前数值。
2. 确定递推公式
- 对于每个正整数
i
:- 我们将其拆分成
j
和i-j
(其中1 <= j < i
)。 - 我们会考虑两种情况:
- 不拆分
i-j
,即直接使用j * (i-j)
。 - 拆分
i-j
,即j * dp[i-j]
。
- 不拆分
- 取这两种情况的最大值,并与
dp[i]
取最大值。递推公式为:
- 我们将其拆分成
dp[i]=max(dp[i],max(j∗(i−j),j∗dp[i−j]))dp[i]=max(dp[i],max(j∗(i−j),j∗dp[i−j]))
3. dp数组如何初始化
- dp数组初始化:
dp[2] = 1
:即将数字2
拆分为1 + 1
,最大乘积为1
。
4. 确定遍历顺序
- 遍历顺序:从
3
到n
依次计算每个i
的最大乘积。 - 对于每个
i
,枚举所有可能的拆分点j
(1
到i-1
)。
5. 举例推导dp数组
假设 n = 10,我们推导dp数组的值。
初始化:
dp
数组初始为:[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]
递推计算步骤:
计算 dp[3]
:
- 拆分(1, 2):最大值为
max(1*2, 1*1) = 2
dp[3] = 2
计算 dp[4]
:
- 拆分(1, 3):最大值为
max(1*3, 1*2) = 3
- 拆分(2, 2):最大值为
max(2*2, 2*1) = 4
dp[4] = 4
计算 dp[5]
:
- 拆分(1, 4):最大值为
max(1*4, 1*4) = 4
- 拆分(2, 3):最大值为
max(2*3, 2*2) = 6
dp[5] = 6
计算 dp[6]
:
- 拆分(1, 5):最大值为
max(1*5, 1*6) = 6
- 拆分(2, 4):最大值为
max(2*4, 2*4) = 8
- 拆分(3, 3):最大值为
max(3*3, 3*2) = 9
dp[6] = 9
计算 dp[7]
:
- 拆分(1, 6):最大值为
max(1*6, 1*9) = 9
- 拆分(2, 5):最大值为
max(2*5, 2*6) = 12
- 拆分(3, 4):最大值为
max(3*4, 3*4) = 12
dp[7] = 12
计算 dp[8]
:
- 拆分(1, 7):最大值为
max(1*7, 1*12) = 12
- 拆分(2, 6):最大值为
max(2*6, 2*9) = 18
- 拆分(3, 5):最大值为
max(3*5, 3*6) = 18
- 拆分(4, 4):最大值为
max(4*4, 4*4) = 16
dp[8] = 18
计算 dp[9]
:
- 拆分(1, 8):最大值为
max(1*8, 1*18) = 18
- 拆分(2, 7):最大值为
max(2*7, 2*12) = 24
- 拆分(3, 6):最大值为
max(3*6, 3*9) = 27
- 拆分(4, 5):最大值为
max(4*5, 4*6) = 24
dp[9] = 27
计算 dp[10]
:
- 拆分(1, 9):最大值为
max(1*9, 1*27) = 27
- 拆分(2, 8):最大值为
max(2*8, 2*18) = 36
- 拆分(3, 7):最大值为
max(3*7, 3*12) = 36
- 拆分(4, 6):最大值为
max(4*6, 4*9) = 36
- 拆分(5, 5):最大值为
max(5*5, 5*6) = 30
dp[10] = 36
最终结果为 dp[10] = 36
。