算法52-----矩阵最小路径【动态规划】
一、题目：矩阵最小路径
给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。
示例:
输入: [ [1,3,1], [1,5,1], [4,2,1] ] 输出: 7 解释: 因为路径 1→3→1→1→1 的总和最小。
思路1：时间O（M*N），空间O（M*N）
新建一个矩阵dp（大小也是M*N），该矩阵是从上往下，从左往右记录每一步的结果的，当前的结果可以根据该矩阵上面和左边最小的值来获得，即：
dp[i][j] = min(dp[i][j-1],dp[i-1][j]) + grid[i][j]
如：
|
grid = [ [1,3,1], |
dp = [[1,4,5], |
所以结果为dp[-1][-1] = 7
代码：
def minPathSum(self, grid):
"""
:type grid: List[List[int]]
:rtype: int
"""
#使用二维数组
if not grid or not grid[0]:
return 0
if len(grid) <= 1:
return sum(grid[0])
dp = [[0]*len(grid[0]) for i in range(len(grid))]
dp[0][0] = grid[0][0]
for i in range(1,len(grid)):
dp[i][0] = grid[i][0] + dp[i-1][0]
for j in range(1,len(grid[0])):
dp[0][j] = grid[0][j] + dp[0][j-1]
for i in range(1,len(grid)):
for j in range(1,len(grid[0])):
dp[i][j] = min(dp[i][j-1],dp[i-1][j]) + grid[i][j]
return dp[-1][-1]
思路2：时间O（M*N），空间O（ min(M,N) )
新建一个列表dp（大小为min(M,N)），循环行数次更新记录每一行的路径值。
如：
grid =
[ [1,3,1],
[1,5,1],
[4,2,1]]
第一次更新：dp = [1，4，5]
第二次更新：dp = [2，7，6]，比如：原本dp = [1，4，5]，然后 先将 dp[0] 更新为2，然后dp[1] : 【min ( dp[0] 和dp [1] ) 与grid [1][1]相加之和】来更新 dp [1]
第三次更新：dp = [6，8，7]
更新是根据：
dp[j] = min(dp[j-1],dp[j]) + grid[i][j]
代码：
#使用一维数组 if not grid or not grid[0]: return 0 if len(grid) <= 1: return sum(grid[0]) if len(grid[0]) <= 1: return sum([val[0] for val in grid]) n = min(len(grid),len(grid[0])) m = len(grid) if n == len(grid[0]) else len(grid[0]) dp = [0] * n dp[0] = grid[0][0] if n == len(grid): grid = list(zip(*grid)) for i in range(1,n): dp[i] = grid[0][i] + dp[i-1] for i in range(1,m): for j in range(n): dp[j] = min(dp[j-1],dp[j]) + grid[i][j] if j>=1 else dp[j] + grid[i][j] return dp[-1]
二、题目：地下城游戏
例如，考虑到如下布局的地下城，如果骑士遵循最佳路径 右 -> 右 -> 下 -> 下，则骑士的初始健康点数至少为 7。
二、思路：动态规划：时间O（M*N），空间O（M*N）
该题与最短路径相反。该题从最右下方开始，求起点。因为题目求的是初始血量，而最短路径求的是终点值，两者相反。
dp[i][j]：如果骑士要走上位置（i,j)，并且从该位置选一条最优的路径，最后走到右下角，骑士起码应具备的血量。最终结果为dp[0][0]。
状态方程：
- 初始化：
-
- dp[m-1][n-1] = 1-dungeon[m-1][n-1] if dungeon[m-1][n-1] < 0 else 1
- for i in range(m-2,-1,-1):
-
dp[i][n-1] = max(dp[i+1][n-1] - dungeon[i][n-1],1)
-
- for j in range(n-2,-1,-1):
dp[m-1][j] = max(dp[m-1][j+1] - dungeon[m-1][j],1)
- dp[i][j] 如何计算？
- 如果骑士向右选择，dp[i][j]_1 = max{ dp[i][j+1] - map[i][j] , 1}
- 如果骑士向下选择，dp[i][j]_2 = max{ dp[i+1][j] - map[i][j] , 1}
- dp[i][j] = min{ dp[i][j]_1, dp[i][j]_2}
代码：
def minHP1(mat): if mat == None or mat[0] == None or len(mat) == 0 or len(mat[0]) == 0: return 1 row = len(mat) col = len(mat[0]) dp = [[0 for i in range(col)] for j in range(row)]
#初始化 dp[row-1][col-1] = max(-mat[row-1][col-1]+1, 1) for i in range(row-2, -1, -1): dp[i][col-1] = max(dp[i+1][col-1] - mat[i][col-1], 1) for j in range(col-2, -1, -1): dp[row-1][j] = max(dp[row-1][j+1] - mat[row-1][j], 1)
#更新dp[i][j] for i in range(row-2, -1, -1): for j in range(col-2, -1, -1): right = max(dp[i][j+1] - mat[i][j], 1) down = max(dp[i+1][j] - mat[i][j], 1) dp[i][j] = min(right, down) return dp[0][0] mat = [[-2,-3,3],[-5,-10,1],[10,30,-5]] minHP1(mat)
三、题目：三角形最小路径和
给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。
例如，给定三角形：
[
[2],
[3,4],
[6,5,7],
[4,1,8,3]
]
自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。
思路：动态规划：时间O（M*N），空间O（M*N），类似矩阵最短路径，从上往下
dp【i】【j】：表示第i行第j列时最短路径。
子问题：邻近的两个：dp[i-1][j-1]、dp[i-1][j]
状态方程：dp[i][j] = min(dp[i-1][j-1],dp[i-1][j]) + triangle[i][j]
代码：
def minimumTotal(self, triangle): """ :type triangle: List[List[int]] :rtype: int """ m = len(triangle) n = len(triangle[0]) if not triangle or m == 0 or n == 0: return 0 dp = [[triangle[0][0]]] for i in range(1,m): dp.append([0] * len(triangle[i])) # print(dp) for i in range(1,m): dp[i][0] = dp[i-1][0] + triangle[i][0] dp[i][-1] = dp[i-1][-1] + triangle[i][-1] for j in range(1,len(dp[i])-1): dp[i][j] = min(dp[i-1][j-1],dp[i-1][j]) + triangle[i][j] return min(dp[-1])
思路：动态规划：空间上优化成O (n) ,类似龙下城游戏，从下往上。
状态方程：dp[j] = min(dp[j],dp[j+1]) + triangle[i][j]
代码：
#一维数组 dp = triangle[-1] for i in range(m-2,-1,-1): for j in range(len(triangle[i])): dp[j] = min(dp[j],dp[j+1]) + triangle[i][j] return dp[0]
四、题目：下降路径最小和
给定一个方形整数数组 A，我们想要得到通过 A 的下降路径的最小和。
下降路径可以从第一行中的任何元素开始，并从每一行中选择一个元素。在下一行选择的元素和当前行所选元素最多相隔一列。
示例：
输入：[[1,2,3],[4,5,6],[7,8,9]] 输出：12 解释： 可能的下降路径有：
[1,4,7], [1,4,8], [1,5,7], [1,5,8], [1,5,9][2,4,7], [2,4,8], [2,5,7], [2,5,8], [2,5,9], [2,6,8], [2,6,9][3,5,7], [3,5,8], [3,5,9], [3,6,8], [3,6,9]
和最小的下降路径是 [1,4,7]，所以答案是 12。
提示：
1 <= A.length == A[0].length <= 100-100 <= A[i][j] <= 100
代码：
def minFallingPathSum(self, A): """ :type A: List[List[int]] :rtype: int """ if not A or len(A[0]) == 0: return 0 m , n = len(A),len(A[0]) dp = [[0] * n for i in range(m)] dp[0] = A[0] for i in range(1,m): for j in range(n): if j==0: dp[i][j] = min(dp[i-1][j+1],dp[i-1][j]) + A[i][j] elif j == n-1: dp[i][j] = min(dp[i-1][j-1],dp[i-1][j]) + A[i][j] else: dp[i][j] = min(dp[i-1][j-1],dp[i-1][j+1],dp[i-1][j]) + A[i][j] return min(dp[-1])
五、有障碍的路径数量【不同路径II】
一个机器人位于一个 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. 向下 -> 向下 -> 向右 -> 向右
代码：
def uniquePathsWithObstacles(self, obstacleGrid): """ :type obstacleGrid: List[List[int]] :rtype: int """ if not obstacleGrid or len(obstacleGrid[0]) == 0 or obstacleGrid[0][0] == 1: return 0 m , n = len(obstacleGrid) , len(obstacleGrid[0]) dp = [[0] * n for i in range(m)] dp[0][0] = 1 if obstacleGrid[0][0] != 1 else 0 for i in range(1,m): if obstacleGrid[i][0] == 0 and dp[i-1][0] == 1: dp[i][0] = 1 for j in range(1,n): if obstacleGrid[0][j] == 0 and dp[0][j-1] == 1: dp[0][j] = 1 for i in range(1,m): for j in range(1,n): if obstacleGrid[i][j] == 0: dp[i][j] = dp[i-1][j] + dp[i][j-1] return dp[-1][-1]
六、题目：出界的路径数：
给定一个 m × n 的网格和一个球。球的起始坐标为 (i,j) ，你可以将球移到相邻的单元格内，或者往上、下、左、右四个方向上移动使球穿过网格边界。但是，你最多可以移动 N 次。找出可以将球移出边界的路径数量。答案可能非常大，返回 结果 mod 109 + 7 的值。
示例 1：
输入: m = 2, n = 2, N = 2, i = 0, j = 0 输出: 6 解释:
示例 2：
输入: m = 1, n = 3, N = 3, i = 0, j = 1 输出: 12 解释:
说明:
- 球一旦出界，就不能再被移动回网格内。
- 网格的长度和高度在 [1,50] 的范围内。
- N 在 [0,50] 的范围内。
思路：
对于一个起始点为i，j，N步可以走出的点的路径个数，等于该点周围的4个点，N-1步可以走出的路径个数之和
dp[k][i][j]表示起点在[i][j]， 第k步可以走出路径个数之和。
代码：
def findPaths(self, m, n, N, i, j): """ :type m: int :type n: int :type N: int :type i: int :type j: int :rtype: int """ dp = [[[0] * n for y in range(m)] for k in range(N+1)] for k in range(1,N+1): for x in range(m): for y in range(n): n1 = dp[k-1][x-1][y] if x >= 1 else 1 n2 = dp[k-1][x][y-1] if y >= 1 else 1 n3 = dp[k-1][x+1][y] if x < m-1 else 1 n4 = dp[k-1][x][y+1] if y < n-1 else 1 dp[k][x][y] = (n1+n2+n3+n4)%(10**9 + 7) return dp[N][i][j]
