动态规划专题

代码随想录中的动态规划

1. 确定DP[i]的含义
2. 确定DP初始化
3. 确定转移方程
4. 确定遍历方向
5. 举例推导DP数组

62. 不同路径

难度:中等

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

1. DP[i] [j]意味着从（0，0）到（i，j）有dp[i] [j]种不同的路径；
2. 举例可知，1*1，1*2，1*3，2*1，3*1都只有一种路线，故DP[i][0] = 1, DP[0][j] = 1；
3. 因为机器人只能向下或向右移动一步，故机器人必定是从dp[i][j-1]或dp[i-1][j]处移动过来的，故dp[i][j] = dp[i][j-1] + dp[i-1][j]；
4. 从上到下，从左到右依次遍历。

 public int uniquePaths(int m, int n) {
     int[][] dp = new int[m][n];
     for(int i = 0;i < m;i++){
         dp[i][0] = 1;
     }
     for(int j = 0;j < n;j++){
         dp[0][j] = 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];
 }

63. 不同路径 II

难度:中等

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？网格中的障碍物和空位置分别用 1 和 0 来表示。

1. DP[i][j]意味着从（0，0）到（i，j）有dp[i][j]种不同的路径；
2. 对于该dp数组的初始化，要考虑到obstacleGrid的情况。在逐行逐列初始化时，在[i][0], [0][j]处碰到障碍物后，后面的方格都处于不可达状态，所以可以直接跳出该层的初始化；
3. 而转移方程依旧是dp[i][j] = dp[i][j-1] + dp[i-1][j]；
4. 从上到下，从左到右依次遍历。额外要注意的点在于，碰到障碍物时，直接跳过该点，因为不可达，所以无需改变状态。

 public int uniquePathsWithObstacles(int[][] obstacleGrid) {
     int m = obstacleGrid.length, n = obstacleGrid[0].length;
     int[][] dp = new int[m][n];
     for(int i = 0;i < m;i++){
         if(obstacleGrid[i][0] == 1){
             break;
         }
         dp[i][0] = 1;
     }
     for(int j = 0;j < n;j++){
         if(obstacleGrid[0][j] == 1){
             break;
         }
         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. 整数拆分

难度:中等751

给定一个正整数 n ，将其拆分为 k 个 正整数 的和（ k >= 2 ），并使这些整数的乘积最大化。返回你可以获得的最大乘积

1. DP[i] 意味着数字i可以被拆分为的最大乘积为dp[i]
2. 对于dp初始化，因为n>=2，dp[0] dp[1]不用考虑初始化，dp[2] = 1即可。
3. 要得到分解后的最大乘积，先考虑将其拆为两个数的和，用j开始循环，循环到i-j结束，则dp[i] = j * (i-j)；再考虑将其拆成多个数的和，再计算乘积，dp[i] = j * dp[i-j]（其实相当于继续拆分i-j这个数）；每次循环都要与上次计算的dp[i]进行比较，故dp[i] = max(dp[i],j*(i-j),j*dp[i-j])
4. 从左到右依次遍历。

public int integerBreak(int n) {
    int[] dp = new int[n+1];
    dp[2] = 1;
    for(int i = 3;i <= n;i++){
        for(int j = 1;j <= i-j;j++){
            dp[i] = Math.max(dp[i], Math.max(j * (i-j), j * dp[i-j]));
        }
    }
    return dp[n];
}