Unique Paths

题目非常简单，没有什么需要讨论的，主要是练习空间优化

class Solution(object):
    def uniquePaths(self, m, n):
        """
        :type m: int
        :type n: int
        :rtype: int
        """
        if not m and not n:
            return 0

        dp = [1] * m
        for i in xrange(1, n):
            for j in xrange(1, m):
                dp[j] += dp[j - 1]
        return dp[m - 1]

此题还有一个数学方法，我们走到最下角的时候必定横向走了n-1步，纵向走了m-1步，所以最后结果就是Cn + m - 2/n - 1，变成了一个单纯排列组合的问题了

class Solution(object):
    def uniquePaths(self, m, n):
        """
        :type m: int
        :type n: int
        :rtype: int
        """
        if n == 1 or m == 1:
            return 1

        total = reduce(operator.mul, range(1, n + m - 1))
        left = reduce(operator.mul, range(1, n))
        right = reduce(operator.mul, range(1, m))
        return total / (left * right)

Unique Paths II

加了一个障碍的判断逻辑，其他没有区别，下面是无优化版本的

class Solution(object):
    def uniquePathsWithObstacles(self, obstacleGrid):
        """
        :type obstacleGrid: List[List[int]]
        :rtype: int
        """
        n = len(obstacleGrid)
        if not n:
            return 0

        m = len(obstacleGrid[0])
        if not m:
            return 0

        dp = [[0] * m for _ in xrange(n)]
        dp[0][0] = 1 if obstacleGrid[0][0] != 1 else 0

        for i in xrange(1, n):
            dp[i][0] = dp[i - 1][0] if obstacleGrid[i][0] != 1 else 0

        for j in xrange(1, m):
            dp[0][j] = dp[0][j - 1] if obstacleGrid[0][j] != 1 else 0

        for i in xrange(1, n):
            for j in xrange(1, m):
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1] if obstacleGrid[i][j] != 1 else 0

        return dp[n - 1][m - 1]

Minimum Path Sum

这道题实际上思维和上面两道是一样的，只不过换成求最小和了而已，下面是无优化版本的

class Solution(object):
    def minPathSum(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: int
        """
        n = len(grid)
        if not n:
            return 0

        m = len(grid[0])
        if not m:
            return 0

        dp = [[0] * m for _ in xrange(n)]
        dp[0][0] = grid[0][0]

        for i in xrange(1, m):
            dp[0][i] = dp[0][i - 1] + grid[0][i]
        for i in xrange(1, n):
            dp[i][0] = dp[i - 1][0] + grid[i][0]

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

        return dp[n - 1][m - 1]