LSGO——LeetCode实战（数组系列）： 62题 不同路径 （Unique Paths）

原题：

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

问总共有多少条不同的路径？

例如，上图是一个7 x 3 的网格。有多少可能的路径？

说明：m 和 n 的值均不超过 100。

示例 1:

输入: m = 3, n = 2
输出: 3
解释:
从左上角开始，总共有 3 条路径可以到达右下角。

1. 向右 -> 向右 -> 向下
2. 向右 -> 向下 -> 向右
3. 向下 -> 向右 -> 向右
   示例 2:

输入: m = 7, n = 3
输出: 28

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/unique-paths
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解法一：排列组合

思路：排列组合
因为机器到底右下角，向下几步，向右几步都是固定的。
比如，m=3, n=2，我们只要向下 1 步，向右 2 步就一定能到达终点。

class Solution(object):
    def uniquePaths(self, m, n):
        """
        :type m: int
        :type n: int
        :rtype: int
        """
        return int(math.factorial(m+n-2)/math.factorial(m-1)/math.factorial(n-1))  # 使用内置函数factorial进行阶乘。

解法二（动态规划）：

思路：我们令 dp[i][j] 是到达 i, j 最多路径
动态方程：dp[i][j] = dp[i-1][j] + dp[i][j-1]
注意，对于第一行 dp[0][j]，或者第一列 dp[i][0]，由于都是在边界，所以只能为 1

程序一：

class Solution(object):
    def uniquePaths(self, m, n):
        """
        :type m: int
        :type n: int
        :rtype: int
        """
        dp = [[1]*n] + [[1]+[0] * (n-1) for _ in range(m-1)]  # 初始化dp数组。
        #print(dp)
        for i in range(1, m):
            for j in range(1, n):
                dp[i][j] = dp[i-1][j] + dp[i][j-1]
        return dp[-1][-1]

程序二：

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

解法三：递归：

程序一：

** 超出时间限制**

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

程序二

** 使用a数组记录路径数，当路径不为0的时候说明该位置已经求算过，直接return。 **

class Solution(object):
    a = [[0] * (101) for i in range(101)]
    def uniquePaths(self, m, n):
        """
        :type m: int
        :type n: int
        :rtype: int
        """
        if m == 1 or  n == 1:
            return 1
        if self.a[m][n] > 0: return self.a[m][n]
        self.a[m][n] = self.uniquePaths(m,n-1)+self.uniquePaths(m-1,n)
        return self.a[m][n]