1. leetcode 64. 最小路径和
给定一个包含非负整数的 m x n 网格，
请找出一条从左上角到右下角的路径，
使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。
示例:
输入:
[
[1,3,1],
[1,5,1],
[4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。
1.1. 暴力
cost(i,j)=grid[i][j]+min(cost(i+1,j),cost(i,j+1))
def minPathSum_1(self, grid):
"""
暴力法
时间复杂度 ：O(2^(m+n})。每次移动最多可以有两种选择。
空间复杂度 ：O(m+n)。递归的深度是 m+n。
:param grid:
:return:
"""
len_i, len_j = len(grid), len(grid[0])
def _helper(grid, i, j, len_i, len_j):
if i == len_i or j == len_j:
return float('inf')
if i == len_i - 1 and j == len_j - 1:
return grid[i][j]
return grid[i][j] + min(_helper(grid, i+1, j, len_i, len_j),
_helper(grid, i, j+1, len_i, len_j),)
return _helper(grid, 0, 0, len_i, len_j)
1.2. 二维动态规划
新建一个额外的dp数组，与原矩阵大小相同。在这个矩阵中，dp(i, j)表示从坐标 (i, j)到右下角的最小路径权值。
初始化右下角的dp值为对应的原矩阵值，然后去填整个矩阵，对于每个元素考虑移动方式，获得最小路径；
如下递推公式：
dp(i,j)=grid(i,j)+min(dp(i+1,j),dp(i,j+1))
注意边界情况。
def minPathSum_2(self, grid):
"""
二维动态规划
时间复杂度 ：O(mn)。遍历整个矩阵恰好一次。
空间复杂度 ：O(n)。额外的矩阵。
:param grid:
:return:
"""
len_i, len_j = len(grid), len(grid[0])
dp = [ [0] * len_j ] * len_i
for i in range(len_i - 1, -1, -1):
for j in range(len_j - 1, -1, -1):
if i == len_i - 1 and j != len_j - 1:
dp[i][j] = grid[i][j] + dp[i][j+1]
elif j == len_j -1 and i != len_i - 1:
dp[i][j] = grid[i][j] + dp[i+1][j]
elif j != len_j -1 and i != len_i - 1:
dp[i][j] = grid[i][j] + min(dp[i+1][j], dp[i][j+1])
else:
dp[i][j] = grid[i][j]
return dp[0][0]
1.2.1. 动态规划优化
在上一解法中使用数组记录了所有的路径值，但实际只需要记录一行的数据，所以可以做如下优化：
def minPathSum_3(self, grid):
"""
动态规划 一维数组
上面的动态规划保存了整个矩阵，
但实际只用保存一行/列的数据即可
时间复杂度 ：O(mn)。遍历整个矩阵恰好一次。
空间复杂度 ：O(n)。额外的一维数组，和一行大小相同。
:param grid:
:return:
"""
len_i, len_j = len(grid), len(grid[0])
dp = [0]*len_j
for i in range(len_i - 1, -1, -1):
for j in range(len_j - 1, -1, -1):
if i == len_i - 1 and j != len_j - 1:
dp[j] = grid[i][j] + dp[j+1]
elif j == len_j - 1 and i != len_i - 1:
dp[j] = grid[i][j] + dp[j]
elif i != len_i - 1 and j != len_j - 1:
dp[j] = grid[i][j] + min(dp[j], dp[j+1])
else:
dp[j] = grid[i][j]
return dp[0]
1.2.2. 优化2
当然也可以使用数组本身的空间，使得所需的额外空间为零。
需要注意的是改变数组本身的行为不要放在其它解决方案测试之前；
否则使用copy.deepcopy()。
def minPathSum_4(self, grid: [[int]]) -> int:
"""
动态规划
不使用额外空间
时间复杂度：O(MN）
空间复杂度：O（1）
:param grid:
:return:
"""
for i in range(len(grid)):
for j in range(len(grid[0])):
if i == j == 0: continue
elif i == 0: grid[i][j] = grid[i][j - 1] + grid[i][j]
elif j == 0: grid[i][j] = grid[i - 1][j] + grid[i][j]
else: grid[i][j] = min(grid[i - 1][j], grid[i][j - 1]) + grid[i][j]
return grid[-1][-1]
2. 完整代码及执行结果
# coding:utf-8
__author__ = "sn"
"""
64. 最小路径和
给定一个包含非负整数的 m x n 网格，
请找出一条从左上角到右下角的路径，
使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。
示例:
输入:
[
[1,3,1],
[1,5,1],
[4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。
"""
"""
思路：
暴力穷举
动态规划
"""
class Solution:
def minPathSum_1(self, grid):
"""
暴力法
时间复杂度 ：O(2^(m+n})。每次移动最多可以有两种选择。
空间复杂度 ：O(m+n)。递归的深度是 m+n。
:param grid:
:return:
"""
len_i, len_j = len(grid), len(grid[0])
def _helper(grid, i, j, len_i, len_j):
if i == len_i or j == len_j:
return float('inf')
if i == len_i - 1 and j == len_j - 1:
return grid[i][j]
return grid[i][j] + min(_helper(grid, i+1, j, len_i, len_j),
_helper(grid, i, j+1, len_i, len_j),)
return _helper(grid, 0, 0, len_i, len_j)
def minPathSum_2(self, grid):
"""
二维动态规划
时间复杂度 ：O(mn)。遍历整个矩阵恰好一次。
空间复杂度 ：O(n)。额外的矩阵。
:param grid:
:return:
"""
len_i, len_j = len(grid), len(grid[0])
dp = [ [0] * len_j ] * len_i
for i in range(len_i - 1, -1, -1):
for j in range(len_j - 1, -1, -1):
if i == len_i - 1 and j != len_j - 1:
dp[i][j] = grid[i][j] + dp[i][j+1]
elif j == len_j -1 and i != len_i - 1:
dp[i][j] = grid[i][j] + dp[i+1][j]
elif j != len_j -1 and i != len_i - 1:
dp[i][j] = grid[i][j] + min(dp[i+1][j], dp[i][j+1])
else:
dp[i][j] = grid[i][j]
return dp[0][0]
def minPathSum_3(self, grid):
"""
动态规划 一维数组
上面的动态规划保存了整个矩阵，
但实际只用保存一行/列的数据即可
时间复杂度 ：O(mn)。遍历整个矩阵恰好一次。
空间复杂度 ：O(n)。额外的一维数组，和一行大小相同。
:param grid:
:return:
"""
len_i, len_j = len(grid), len(grid[0])
dp = [0]*len_j
for i in range(len_i - 1, -1, -1):
for j in range(len_j - 1, -1, -1):
if i == len_i - 1 and j != len_j - 1:
dp[j] = grid[i][j] + dp[j+1]
elif j == len_j - 1 and i != len_i - 1:
dp[j] = grid[i][j] + dp[j]
elif i != len_i - 1 and j != len_j - 1:
dp[j] = grid[i][j] + min(dp[j], dp[j+1])
else:
dp[j] = grid[i][j]
return dp[0]
def minPathSum_4(self, grid: [[int]]) -> int:
"""
动态规划
不使用额外空间
时间复杂度：O(MN）
空间复杂度：O（1）
:param grid:
:return:
"""
for i in range(len(grid)):
for j in range(len(grid[0])):
if i == j == 0: continue
elif i == 0: grid[i][j] = grid[i][j - 1] + grid[i][j]
elif j == 0: grid[i][j] = grid[i - 1][j] + grid[i][j]
else: grid[i][j] = min(grid[i - 1][j], grid[i][j - 1]) + grid[i][j]
return grid[-1][-1]
import timeit
from collections import Iterable
def processing_func(cls, func_name, *ar, **kw):
func = getattr(cls, func_name)
if isinstance(ar[0], Iterable):
res = func(*ar[0])
else:
res = func()
# 打印执行结果
print('执行结果：', res)
import timeit
def test_func(cls, *ar):
# 方法执行耗时
time_cost = dict()
# 获取并执行Solution类中的解决方法
func_list = [x for x in dir(cls) if not x.startswith('__')]
print('\r\n', "共计有<%d>个方法："%(len(func_list)), func_list)
# 设置参数
# 依次执行Solution类中的方法
for i, _ in enumerate(func_list, 1):
# 跳过
#if i == 1: continue
# 设置参数
func = getattr(cls, _)
# print(cls, func_num, func, ar)
# 打印方法说明文档
print("\r\n", "*" * 40, "\r\n方法[%s]：%s\r\n说明：%s" % (i, _, func.__doc__.strip()),)
# 执行方法并记录执行时长
t = timeit.timeit(stmt="processing_func(so, '{}', para)".format(_),
setup='from __main__ import processing_func, so, para',
number= 1
)
time_cost[_] = t
print('\r\n执行时长：', *time_cost.items(), sep='\r\n')
if __name__ == "__main__":
# 实例化解决方案类
so = Solution()
# 参数设定
li = [
[1, 3, 1],
[1, 5, 1],
[4, 2, 1],
]
para = (li,)
test_func(so, para)
pass
2.1. 执行结果
共计有<4>个方法： ['minPathSum_1', 'minPathSum_2', 'minPathSum_3', 'minPathSum_4']
****************************************
方法[1]：minPathSum_1
说明：暴力法
时间复杂度 ：O(2^(m+n})。每次移动最多可以有两种选择。
空间复杂度 ：O(m+n)。递归的深度是 m+n。
:param grid:
:return:
执行结果： 7
****************************************
方法[2]：minPathSum_2
说明：二维动态规划
时间复杂度 ：O(mn)。遍历整个矩阵恰好一次。
空间复杂度 ：O(n)。额外的矩阵。
:param grid:
:return:
执行结果： 7
****************************************
方法[3]：minPathSum_3
说明：动态规划 一维数组
上面的动态规划保存了整个矩阵，
但实际只用保存一行/列的数据即可
时间复杂度 ：O(mn)。遍历整个矩阵恰好一次。
空间复杂度 ：O(n)。额外的一维数组，和一行大小相同。
:param grid:
:return:
执行结果： 7
****************************************
方法[4]：minPathSum_4
说明：动态规划
不使用额外空间
时间复杂度：O(MN）
空间复杂度：O（1）
:param grid:
:return:
执行结果： 7
执行时长：
('minPathSum_1', 0.00013762672739037798)
('minPathSum_2', 3.638943978457454e-05)
('minPathSum_3', 2.332656396447088e-05)
('minPathSum_4', 2.239350140589196e-05)