python动态规划几条路径_解决不同路径问题的Python动态规划

一、【LeetCode 62】不同路径

1. 题目描述

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

机器人

每次只能向下或者向右移动一步

。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

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

例如，上图是一个7 x 3 的网格。有多少可能的路径？

示例 1:

输入: m = 3, n = 2

输出: 3

解释:

从左上角开始，总共有 3 条路径可以到达右下角。

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

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

3. 向下 -> 向右 -> 向右

示例 2:

输入: m = 7, n = 3

输出: 28

提示：

1 <= m, n <= 100

题目数据保证答案小于等于 2 * 10 ^ 9

2. 解题思路

这是一个经典的

动态规划

问题，关键是要

想明白如何去计算其中的某一个格子到达它的路径有多少条

，计算方式就是到达它上面的格子的路径数加上到达它左边的格子的路径数。

首先初始化一个二维数组memo（m行n列，每个元素的初始值为0）

memo = [[0 for j in range(n)] for i in range(m)]

接着对memo数组的第一行和第一列进行初始化：因为机器人每次

只能向下或者向右移动一步

，不能向左向上往回走，所以可以将 memo 数组的

第一行和第一列的值全部初始化为1

（

因为到达第一行的每个格子只有一直往右走这一种走法，同理到达第一列的每个格子也只有一直往下走这一种走法

）

接下来就是双重循环，考虑数组内部的值，每一个格子的值都等于上一个格子的值加上左边格子的值

memo[i][j] = memo[i - 1][j] + memo[i][j - 1]

，可见下图：

这样依次算出memo数组的每一个值后，直接返回右下角的数值即可

return memo[-1][-1]

。

3. 代码

class Solution:

def uniquePaths(self, m: int, n: int) -> int:

memo = [[0 for j in range(n)] for i in range(m)]

for i in range(m):

memo[i][0] = 1

for j in range(n):

memo[0][j] = 1

for i in range(1, m):

for j in range(1, n):

memo[i][j] = memo[i - 1][j] + memo[i][j - 1]

return memo[-1][-1]

二、【LeetCode 63】不同路径II

1. 题目描述

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

机器人

每次只能向下或者向右移动一步

。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

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

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

说明：

m 和 n 的值均不超过 100。

示例 1:

输入:

[

[0,0,0],

[0,1,0],

[0,0,0]

]

输出: 2

解释:

3x3 网格的正中间有一个障碍物。

从左上角到右下角一共有 2 条不同的路径：

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

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

2. 解题思路

本题和上题不同之处在于本题设置了障碍物，机器人不再是畅通无阻的前进，思路有点点绕：

首先由障碍网格获取行数m和列数n，进行边界条件判断，当

m=0或n=0

，换句话说就是只有一列或一行时，

有障碍物的存在永远无法到达终点

，这种情况直接返回0即可。

接下来创建一个

二维数组memo

（

m行n列，数组内所有值均为0

），然后考虑特殊情况：当起始的地方就有一个障碍物（也就是

obstacleGrid[0][0] == 1

时），也是无法走到终点的，直接return 0；起始地没有障碍物时就可将 memo[0][0] 置为1。

接下来最关键的就是memo数组第一行和第一列的初始化：

因为本题存在障碍物，所以本题不能像上题那样单纯的将第一行和第一列全部置为1，因为一旦第一行或第一列出现障碍物，后面的格子就无法到达了，应为0

。所以要进行判断，可以先考察 obstacleGrid 中每一行的第一个数字

for i in range(1, m)

是否为1

if obstacleGrid[i][0] == 1:

若是的话直接跳出循环，后面的格子就不用看了，全部为最开始创建数组时设置的0；若不是，就可将memo[i][0]置为1.每一列的第一个数字同理。

再接着就是双重循环看obstacleGrid内部数字，

若发现obstacleGrid[i][j] 等于 1，就将相应的 memo[i][j] 置为 0

；

否则还是与上题相同，当前格子的值=上一个格子的值+左边格子的值

：

memo[i][j] = memo[i - 1][j] + memo[i][j - 1]

见下图：

3. 代码

class Solution:

def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:

m = len(obstacleGrid)

n = len(obstacleGrid[0])

if m == 0 or n == 0:

return 0

memo = [[0 for j in range(n)]for i in range(m)]

if obstacleGrid[0][0] == 1:

return 0

memo[0][0] = 1

for i in range(1, m):

if obstacleGrid[i][0] == 1:

break

else:

memo[i][0] = 1

for j in range(1, n):

if obstacleGrid[0][j] == 1:

break

else:

memo[0][j] = 1

for i in range(1, m):

for j in range(1, n):

if obstacleGrid[i][j] == 1:

memo[i][j] = 0

else:

memo[i][j] = memo[i - 1][j] + memo[i][j - 1]

return memo[-1][-1]

三、【LeetCode 64】最小路径和

1. 题目描述

给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：

每次

只能向下或者向右移动一步

。

示例:

输入:

[

[1,3,1],

[1,5,1],

[4,2,1]

]

输出: 7

解释: 因为路径 1→3→1→1→1 的总和最小。

2. 解题思路

本题与62题类似，62题求得是从起点左上角到终点右下角的所有不同路径，而本题相当于是求这些路径中和最小的一条，思路差不多，依旧使用

动态规划

——

首先还是获取网格的行数m和列数n，并进行边界判断：当m=0且n=0，也就是说当这个网格为空时，没有路径可走，直接返回0即可。

接下来创建二维数组memo（m行n列，数组内所有值全为0），设置 memo[0][0] 的值：

memo[0][0] = grid[0][0]

（到达第一个格子的最短路径肯定是自身的值）

接下来初始化memo数组的第一行和第一列，因为机器人每次

只能向下或者向右移动一步

，不能向左向上往回走，所以可以将 memo 数组的

第一行每个格子的值等于前一个格子的值加上当前对应的grid里的值：

memo[0][j] = memo[0][j-1] + grid[0][j]

，第一列同理

（

因为到达第一行的每个格子只有一直往右走这一种走法，同理到达第一列的每个格子也只有一直往下走这一种走法

）

接下来就是双重循环，62题是将上一个格子的值加上左边格子的值就是当前格子的值，而本题是取上一个格子和左边格子中更小的那一个加上当前格子对应grid里的值，才是memo[i][j]的值：

memo[i][j] = min(memo[i-1][j], memo[i][j-1]) + grid[i][j]

，见下图：

像这样算出memo所有值后，返回最后一个值即可：

return memo[-1][-1]

3. 代码

class Solution:

def minPathSum(self, grid: List[List[int]]) -> int:

m = len(grid)

n = len(grid[0])

if m == 0 and n == 0:

return 0

memo = [[0 for j in range(n)] for i in range(m)]

memo[0][0] = grid[0][0]

for i in range(1, m):

memo[i][0] = memo[i-1][0] + grid[i][0]

for j in range(1, n):

memo[0][j] = memo[0][j-1] + grid[0][j]

for i in range(1, m):

for j in range(1, n):

memo[i][j] = min(memo[i-1][j], memo[i][j-1]) + grid[i][j]

return memo[-1][-1]