代码随想录Day43

今天继续学习动态规划解决相关问题。

62.不同路径

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

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

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

示例 1：

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

 思路：

1.本题实际上在当年大一刚开始学C语言时作为一道作业就接触到了，但当时的自己还什么都不会于是被这道题薄纱（现在仍然记忆深刻）。

2.题外话结束。首先确定dp数组，本题中因为是在一个二维矩阵中移动，因此选择二维的dp数组，下标i，j分别代表第i行第j列，dp[i][j]代表到达第i行第j列的那个点有多少种路径。

3.通过题目描述可以知道，要想到达[i][j]位置只能从其左边和上边到达，即到达当前格子的路径等于其上方格子的路径加上左方格子的路径。因此dp[i][j] = dp[i - 1][j] + dp[i][j - 1]。

4.关于初始化，既然当前格由上方的格子和左方的格子确定，那么第一行和第一列的格子显然必须初始化，且到达他们的路径只有一条，即一直向右走或者一直向下走。

5.递归顺序显然是从左上到右下遍历，i和j都是递增。

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector> dp(m, vector(n,0));

        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.不同路径||

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

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

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

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

示例 1：

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

思路：

1.本题与上一题思路基本一致。但是在原有基础之上加入了障碍物，因此在初始化第一行和第一列时如果遇见障碍物，那么其之后的所有元素都不应当再进行赋值（因为不可能到达） ；在遍历过程中也要额外判断如果当前位置是障碍物，那么应当直接跳过。

class Solution {
public:
    int uniquePathsWithObstacles(vector>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();

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

        vector>dp(m, vector(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];
    }
};

启发：

1.对于这类路径题目，一定要想清楚当前位置能够通过哪些其他位置到达，弄清楚要求的是什么（以上两题中求的都是路径条数，实际上也有可能求到达终点耗费体力之类的最少的路径等）

343.整数拆分

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

返回 你可以获得的最大乘积 。

示例 1:

输入: n = 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1。

思路：

1.首先想dp数组及其下标的含义，i就是给定的正整数n，dp[i]就是将i拆分后得到的最大乘积

2.接下来想递推公式。本题比较难想的一个点就是我们到底要拆成几个数？如果我们将i拆分成两个数其实很好想，就是j * (i - j)，拆分成三个数，四个数呢？

实际上我们可以在拆分成两个数的基础上进一步拆分i - j，转化为 j * dp[i - j]。可能仍旧会疑惑：那到底是拆成了几个数啊？这里我们就不用管具体到底拆成几个数了，因为不管i - j被拆分成几个数，dp[i - j]就是其拆分后最大的乘积。

因此递推公式就是：dp[i] = max(max(j * (i - j), j * dp[i - j]), dp[i])。这里可能又有疑惑：为什么取最大值的时候还要把dp[i]也取进去？因为在每一次推导的过程中，j从1开始遍历到i - 1，每次计算dp[i]都要取最大的。

3.然后进行初始化，对于dp[0]和dp[1]实际上没有意义，因为这俩根本不能拆分，对于dp[2]题目已经给出为1。

4.最终确定遍历的顺序，因为dp[i]的结果依赖于dp[i - j]的结果，因此我们的遍历顺序是从前向后。

class Solution {
public:
    int integerBreak(int n) {
        vector dp(n + 1);

        dp[2] = 1;
        for(int i = 3; i <= n; i++){
            for(int j = 1; j <= i / 2; j++){
                dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]));
            }
        }

        return dp[n];
    }
};

启发：

1.本题实际上没有必要让j遍历到i - 1，遍历到i / 2即可。因为要使得dp[i]最大，拆分的数应当尽可能的相似，为了使拆分的数尽可能相似，我们应当拆分的是大数而非小数。当j > i / 2后，此时i - j已经比j小，拆分的反而是小数，因此不可能得到最大值。