19——透彻理解动态规划

动态规划是热门、最重要的算法之一，解决的思路为：一、确定状态和子问题，也就是枚举出某个位置所有的可能性，得到递推关系同时将问题转换为子问题。二、确定状态转移方程。三、确定初始条件和边界情况。四、按照从小到大的顺序计算，下面将举例说明。

1、leetcode62，一个机器人位于一个mxn网络的左上角，机器人只能向下或者向右移动一步，当机器人到达网络的左下角，总共有多少条路径。

        对于该题每个网格的路径数量等于左边路径数量+右边路径数量，因此可以用一维数组来存储每个网格的结果，最后一个网格即是我们需要的答案，代码参考如下：

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        dp = [1]*n
        for i in range(1, m):
            for j in range(1, n):
                dp[j] += dp[j-1]
        return dp[-1]

2、leetcode64，给定一个包含非负数组的mxn网络gird，请找出一条从左上角到右下角的路径，使得路径上的数字总和最小。该题设计到最优子结构问题，当前节点路径和的最小值=左边或者上边路径的最小值加上当前节点的路径，注意处理好边界即可。

class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        m, n = len(grid), len(grid[0])
        for i in range(1, m):
            grid[i][0] += grid[i-1][0]
        for j in range(1, n):
            grid[0][j] += grid[0][j-1]

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

3、Leetcode120，本题是上一题的简单变形，给定一个三角形triangle，找出自顶向下的最小路径和，每一步只能移动到下一行的相邻结点上，也就是转换成下三角矩阵，下一行的第一个值，只能有上一行的第一个值获得，而最后一个值只能有上一行的最后一个值获得，因此，当不为第一个和最后一个值时，状态转移矩阵dp[i][j]=min(dp[i-1][j], dp[i-1][j-1]) + cur[j]，同时最小路径min(dp[-1])，二维数组参考如下：

class Solution:
    def minimumTotal(self, triangle: List[List[int]]) -> int:
        n = len(triangle)
        dp = [[0]*n for _ in range(n)]
        dp[0][0] = triangle[0][0]
        for i in range(1, n):
            dp[i][0] = dp[i-1][0] + triangle[i][0] 
            for j in range(1, i):
                dp[i][j] = min(dp[i-1][j], dp[i-1][j-1]) + triangle[i][j]
            dp[i][i] = dp[i-1][i-1] + triangle[i][i]
        return min(dp[n-1])

同时还可以使用一维数组优化，只需要保存上一层cur的值，因为这一层的值根据上一层和当前层的triangle即可计算出来的。

class Solution:
    def minimumTotal(self, triangle: List[List[int]]) -> int:
        n = len(triangle)
        cur = triangle[0]
        for i in range(1, n):
            triangle[i][0] += cur[0] 
            for j in range(1, i):
                triangle[i][j] = min(triangle[i-1][j], cur[j-1]) + triangle[i][j]
            triangle[i][i] += cur[-1]
            cur = triangle[i]
        return min(triangle[-1])