代码随想录Day39：不同路径、不同路径 II、整数拆分

最新推荐文章于 2024-10-01 22:51:02 发布

糖醋圆白菜.

最新推荐文章于 2024-10-01 22:51:02 发布

阅读量128

点赞数 1

分类专栏：代码随想录一刷文章标签：数据结构算法 leetcode

本文链接：https://blog.csdn.net/weixin_47513070/article/details/136521764

版权

代码随想录一刷专栏收录该内容

52 篇文章 0 订阅

订阅专栏

文章讨论了两种基于动态规划的解决方案：计算给定网格中无障碍路径的数量（uniquePaths），以及在有障碍物的情况下计算独特路径（uniquePathsWithObstacles）。还介绍了如何用动态规划求解整数的最优拆分（integerBreak），以获取最大乘积。

摘要由CSDN通过智能技术生成

不同路径

class Solution {
public:
    /*动态规划五部曲：
        1、确定dp数组以及下标的含义：dp[i][j]，到dp[i][j]位置上的不同路径数量；

        2、确定递推公式:每次可由上边或者左边的位置移动而来，所以dp[i][j] = dp[i-1][j] + dp[i][j-1]；

        3、dp数组如何初始化：dp[0][i]=1，dp[i][0]=1；

        4、确定遍历顺序：根据递推公式，从前往后遍历，从上往下遍历；

        5、举例推导dp数组；
    */
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m, vector<int>(n, 0));
        for(int i = 0; i < m; i++) dp[i][0] = 1;
        for(int i = 0; i < n; i++) dp[0][i] = 1;
        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];
    }
};

不同路径 II

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        vector<vector<int>> dp(m, vector<int>(n, 0));
        for(int i = 0; i < m; i++){
            if(obstacleGrid[i][0] == 1) break;
            dp[i][0] = 1;
        }
        for(int i = 0; i < n; i++){
            if(obstacleGrid[0][i] == 1) break;
            dp[0][i] = 1;
        }
        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
                if(obstacleGrid[i][j] == 1) dp[i][j] = 0;
                else dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
};

整数拆分

class Solution {
public:
    int integerBreak(int n) {
        vector<int> dp(n+1);      //dp[i]为拆分正整数i的最大乘积；
        dp[2] = 1;              //dp[0]、dp[1]没有实际意义，从索引2开始初始化dp[]；
        for(int i = 3; i <= n; i++){
            for(int j = 1; j <= i/2; j++){
                dp[i] = max(dp[i], max((i-j)*j, dp[i-j]*j));
            }
        }
        return dp[n];
    }
};