LeetCode #62 #63 #64 #174 2018-08-20

动态规划篇

动态规划的题目相对较难而且耗时，所以面试的时候遇到的几率并不大，但也不是没有。所以该篇将分别介绍动态规划是什么，动态规划的主要组成要素，什么时候使用动态规划以及动态规划题目的分类，并将针对不同类型使用不同的例题进行讲解。

动态规划的通常思路：
动态规划是一种算法思路（注意这里不要和递归混淆，事实上递归和迭代只是两种不同的实现方法，并不是算法），用一句话来总结就是，动态规划是利用存储历史信息使得未来需要历史信息时不需要重新计算，从而达到降低时间复杂度，用空间复杂度换取时间复杂度目的方法。我个人喜欢把动态规划分为以下几步：
1）确定递推量。这一步需要确定递推过程中要保留的历史信息数量和具体含义，同时也会定下动态规划的维度；
2）推导递推式。根据确定的递推量，得到如何利用存储的历史信息在有效时间（通常是常量或者线性时间）内得到当前的信息结果；
3）计算初始条件。有了递推式之后，我们只需要计算初始条件，就可以根据递推式得到我们想要的结果了。通常初始条件都是比较简单的情况，一般来说直接赋值即可；
4）考虑存储历史信息的空间维度（可选）。这一步是基于对算法优化的考虑，一般来说几维动态规划我们就用几维的存储空间是肯定可以实现的。但是有时我们对于历史信息的要求不高，比如这一步只需要用到上一步的历史信息，而不需要更早的了，那么我们可以只存储每一步的历史信息，每步覆盖上一步的信息，这样便可以少一维的存储空间，从而优化算法的空间复杂度。
动态规划的时间复杂度是O(（维度）×（每步获取当前值所用的时间复杂度）)。基本上按照上面的思路，动态规划的题目都可以解决，不过最难的一般是在确定递推量，一个好的递推量可以使得动态规划的时间复杂度尽可能的低。

什么时候考虑使用动态规划：

1. 当题目让我们找Maximum或者Minimum的时候。
2. 当题目让我们判断Yes或者No的时候。
3. 当题目让我们count all possible solutions的时候。

动态规划最常见题目的分类：

1. Matrix Dynamic Programming
2. Sequence Dynamic Programming
3. Two Sequences Dynamic Programming
4. Back Pack

Part 1 – Matrix Dynamic Programming

这类题目是动态规划当中相对简单的，当我们明确了4个主要元素，问题就会迎刃而解。
1）确定递推量。res[x][y]一般表示从起点走到x, y时的状态；
2）推导递推式。一般可以研究最后一步应该如何走；
3）计算初始条件。起点/终点；
4）考虑存储历史信息的空间维度（可选）。二维动态规划使用二维空间肯定可以解决。但这类题往往对于历史信息的要求不高，这一层只需要用到上一层的历史信息，所以我们可以使用一维空间来解决即可，优化空间复杂度使其降低一个纬度。

62. Unique Paths

https://leetcode.com/problems/unique-paths/description/

res[x][y]代表起点到该点共有的路径数。二维空间稳定，一维空间最优。
二维空间代码如下：

class Solution:
    def uniquePaths(self, m, n):
        """
        :type m: int
        :type n: int
        :rtype: int
        """
        res = [[1 for j in range(n)] for i in range(m)]
        for i in range(1, m):
            for j in range(1, n):
                res[i][j] = res[i-1][j] + res[i][j-1]
        return res[-1][-1]

一维空间代码如下：

class Solution:
    def uniquePaths(self, m, n):
        """
        :type m: int
        :type n: int
        :rtype: int
        """
        res = [1 for x in range(n)]
        for i in range(1, m):
            for j in range(1, n):
                res[j] += res[j-1]
        return res[-1]

这道题还有一种组合公式法。

63. Unique Paths II

https://leetcode.com/problems/unique-paths-ii/description/

res[x][y]代表起点到该点共有的路径数。可以使用参数数组，不需要额外空间。注意对i == 0这行，j == 0这列的处理即可。
代码如下：

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid):
        """
        :type obstacleGrid: List[List[int]]
        :rtype: int
        """
        m = len(obstacleGrid)
        n = len(obstacleGrid[0])
        obstacleGrid[0][0] = 1 - obstacleGrid[0][0]
        for i in range(1, m):
            if obstacleGrid[i][0]:
                obstacleGrid[i][0] = 0
            else:
                obstacleGrid[i][0] = obstacleGrid[i-1][0]
        for j in range(1, n):
            if obstacleGrid[0][j]:
                obstacleGrid[0][j] = 0
            else:
                obstacleGrid[0][j] = obstacleGrid[0][j-1]
        for i in range(1, m):
            for j in range(1, n):
                if obstacleGrid[i][j]:
                    obstacleGrid[i][j] = 0
                else:
                    obstacleGrid[i][j] = obstacleGrid[i-1][j] + obstacleGrid[i][j-1]
        return obstacleGrid[-1][-1]

64. Minimum Path Sum

https://leetcode.com/problems/minimum-path-sum/description/

res[x][y]代表起点到该点最小的路径值。每次取左边或者上边最小的值与当前点值的和即可。可以使用参数数组，不需要额外空间。注意对i == 0这行，j == 0这列的处理即可。
代码如下：

class Solution:
    def minPathSum(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: int
        """
        m = len(grid)
        n = 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])
        return grid[-1][-1]

174. Dungeon Game

https://leetcode.com/problems/dungeon-game/description/

从终点逆推回起点的案例。同样可以使用矩阵自身来降低空间复杂度。注意对i == m这行，j == n这列的处理即可。
代码如下：

class Solution:
    def calculateMinimumHP(self, dungeon):
        """
        :type dungeon: List[List[int]]
        :rtype: int
        """
        m = len(dungeon)
        n = len(dungeon[0])
        for i in range(m)[::-1]:
            for j in range(n)[::-1]:
                if i == m-1 and j == n-1:
                    dungeon[i][j] = max(1, 1-dungeon[i][j])
                elif i == m-1:
                    dungeon[i][j] = max(1, dungeon[i][j+1]-dungeon[i][j])
                elif j == n-1:
                    dungeon[i][j] = max(1, dungeon[i+1][j]-dungeon[i][j])
                else:
                    dungeon[i][j] = max(1, min(dungeon[i+1][j], dungeon[i][j+1])-dungeon[i][j])
        return dungeon[0][0]