day34 代码随想录 | 不同路径 整数拆分

不同路径

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

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。问总共有多少条不同的路径？

这个题其实思路很好想。典型的动态规划题目。同样采样动态规划五部曲

1. dp数组的含义。dp[i][j]就是代表从(0,0）到[i,j]的路径数量

2. 递推公式。你走到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,0] = 1 同样第一行和第一列都应该为1 

4. 遍历顺序 从左右右 从上到下

5. 测试

def uniquePaths(m: int, n: int) -> int:
    dp = [[0]*n for _ in range(m)]
    for i in range(m):
        dp[i][0] = 1
    for j in range(n):
        dp[0][j] = 1

    for i in range(1, m):
        for j in range(1, n):
            dp[i][j] = dp[i-1][j] + dp[i][j-1]

    return dp[-1][-1]
    

不同路径II

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

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

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

这个题与上面一个题的不同点在于，有障碍。其实就考察我们对障碍如何处理。

首先，dp[i][j] 就是障碍，那么其实dp[i][j] 就是应该为0

还有就是最容易被忽略或者错误认识的点，就是数组的初始化。

我们很容易想到，当遇到障碍物，应该初始化为0

但是，在初始化第一行和第一列的时候，如果你在遍历的过程中遇到了障碍，那么之后的dp[i][j]应该为0，不应该为1！

def uniquePathsWithObstacles(obstacleGrid: List[List[int]]) -> int:
    m, n = len(obstacleGrid), len(obstacleGrid[0])

    dp = [[0] * n for _ in range(m))

    for i in range(m):
        if obstacleGrid[i][0] == 1:
            break
        else:
            dp[i][0] = 1

    for j in range(n):
        if obstacleGrid[0][j] == 1:
            break
        else:
            dp[0][j] = 1


    for i in range(1, m):
        for j in range(1, n):
            if obstacleGrid[i][j] == 1:
                dp[i][j] = 0

            else:
                dp[i][j] == dp[i-1][j] + dp[i][j-1]

    return dp[-1][-1]

    
    

整数拆分

给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。 返回你可以获得的最大乘积。

示例 1:

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

这个题呢，你要明确，不一定一个只是拆分为两个数，可以拆分为多个数。那么如果拆分为多个数，你该怎么做呢。其实这就涉及到了动态规划，那就是知道你拆分的前面的数的状态。需要哟个dp数组保存。

那么就是dp五部曲

1. dp数组的含义。dp[i] 是指拆分i所能得到最大乘积

2. dp递推公式。dp[i] 拆分 假设我们进行遍历从1到j j是小于i//2 + 1的，那么得到值可以是j*(i-j) 表明拆分为两个数，那么如果拆分多个，则是j * dp[i-j]  我们需要从这里面选择最大的

3. dp初始化，dp[0] 和dp[1] 是没有意义的 dp[2] = 1 

4. 遍历 双层遍历 i从3到n+1 j到i//2 + 1

5. 测试

def integerBreak(n: int) -> int:
    dp = [0] * (n+1)

    dp[2] = 1

    for i in range(3, n+1):
        for j in range(1, i//2 + 1):
            dp[i] = max(dp[i], (i-j)*j, j * dp[i-j])

    return dp[n]