代码随想录day34 || 62不同路径 63不同路径2 343整数拆分

最新推荐文章于 2024-09-10 23:49:32 发布

henu大肠杆菌

最新推荐文章于 2024-09-10 23:49:32 发布

阅读量1k

点赞数 30

文章标签： leetcode 动态规划算法

本文链接：https://blog.csdn.net/2301_80639580/article/details/140924013

版权

动归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] 取最大值。递推公式为：