动态规划day33|62. 不同路径、63. 不同路径 II（对障碍物的处理）、343. 整数拆分（理解有难度）

62. 不同路径

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

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

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

示例 1：

输入：m = 3, n = 7
输出：28

示例 2：

输入：m = 3, n = 2
输出：3
解释：
从左上角开始，总共有 3 条路径可以到达右下角。
1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下

示例 3：

输入：m = 7, n = 3
输出：28

示例 4：

输入：m = 3, n = 3
输出：6

提示：

• 1 <= m, n <= 100
• 题目数据保证答案小于等于 2 * 109

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m,vector<int>(n));
        dp[0][0]=1;
        for(int i=1;i<m;i++)
            dp[i][0]=dp[i-1][0];
        for(int j=1;j<n;j++)
            dp[0][j]=dp[0][j-1];
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                dp[i][j]=dp[i][j-1]+dp[i-1][j];
            }
        }
        return dp[m-1][n-1];
    }
};

难点：

• 初始化，我第一次做就是错在初始化上，这里的初始化不仅要给第一个数负值，而且要给第一列和第一行的值全部赋值

• 递推公式：

   dp[i][j]=dp[i][j-1]+dp[i-1][j];

只要明确了 dp的含义（到达这个位置的路径数），还是很容易想到的。

63. 不同路径 II

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

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

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。

输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
输出：2
解释：3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：

1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右

输入：obstacleGrid = [[0,1],[0,0]]
输出：1

提示：

• m == obstacleGrid.length
• n == obstacleGrid[i].length
• 1 <= m, n <= 100
• obstacleGrid[i][j] 为 0 或 1

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));
        if(obstacleGrid[0][0]==1||obstacleGrid[m-1][n-1]==1)
        return 0;
        dp[0][0]=1;
        for(int i=1;i<m&&obstacleGrid[i][0]==0;i++)
            dp[i][0]=1;
        for(int j=1;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][j-1]+dp[i-1][j];
            }
            return dp[m-1][n-1];
    }    
};

我第一次没做出来，是因为我不知道该怎么去表示2个级以上的障碍物。因为我原来的思路是找到障碍物的下标，然后赋为0，结果这样只能对付只有一个障碍物的情况。

看了题解发现，我们根本不需要找到障碍物的下标，因为障碍物已经在obstacleGrid数组里面表示了，由于obstacleGrid和dp都是二维数组，而且下标一一对应，所以只要利用obstacleGrid [i] [j]是否等于1就可以判断出这个坐标是不是障碍物了。

难点：

​ **对障碍物的处理，**当遇到障碍物时，直接跳过，使用默认值（0）：如果是初始化，要跳出整个循环；如果是递推公式的循环里，要跳出该层循环。

易错点：

• 剪枝，当障碍物处于起始或终止位置时：

  if(obstacleGrid[0][0]==1||obstacleGrid[m-1][n-1]==1)
          return 0;

for(int i=1;i<m&&obstacleGrid[i][0]==0;i++)
              dp[i][0]=1;

在这个循环里，如果obstacleGrid [i] [0]==1了，那么就直接跳出整个for循环，之后的都不再执行了，要注意。

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。

提示:

• 2 <= n <= 58

class Solution {
public:
    int integerBreak(int n) {
        vector<int> dp(n+1);
        dp[2]=1;
        for(int i=3;i<=n;i++)
            for(int j=1;j<=i/2;j++)
            {
                dp[i]=max(max(j*(i-j),j*dp[i-j]),dp[i]);
            }
        return dp[n];
    }
};

难点：

• **dp[i]的含义：**整数i拆分后的最大乘积值，也就是说，dp[n]就是最后的答案（经常如此）

• 怎么拆？两种方式，一是拆成2个，二是拆成多个，取最大值即可。然后不停地与上一个dp[i]比较，来获得最大的dp[i],即：

  dp[i]=max(max(j*(i-j),j*dp[i-j]),dp[i]);