Leetcode62. Unique Paths-动态规划/数学公式

题目

题目链接

思路

两种思路:1.动态规划 2.数学公式

1. 动态规划1
   用一个表$dp$记录每个位置的总数,每个位置上只能从左或从上到达,因此值是上边格子的值加上左边格子的值:
   $dp[i][j]=dp[i-1][j]+dp[i][j-1]$

1	1	1	1	1
1	2	3	4	5
1	3	6	10	15
1	4	10	20	35

2. 动态规划2
   优化空间复杂度
   由于第一行和第一列一定都是1,每次只是更新红框内的行,因此只记录这一行即可
   
3. 数学公式
   由于从左上角到右下角,一定有m - 1次向下,n - 1次向右,
   走过路径长度一定为(m - 1) + (n - 1),
   因此总路径数就是在这(m - 1) + (n - 1)中选出m - 1个向下,或n - 1个向右的组合数,
   即$C_{m+n-2}^{m-1}$,或$C_{m+n-2}^{n-1}$
   对组合数$C_{a+b}^a=\frac{(a+b)!}{a!b!}$,
   如果直接求三个阶乘数,可能时间更长,考虑到分子和分母都从1开始累乘,可以进行化简:
   $$C_{a+b}^a=\frac{(a+b)!}{a!b!}=(\prod _{i=max(a,b)}^{a+b}i\ast \prod _{i=1}^{max(a,b)}i)/(\prod _{i=1}^{min(a,b)}i\ast \prod _{i=1}^{max(a,b)}i)=\prod _{i=max(a,b)}^{a+b}i/\prod _{i=1}^{min(a,b)}i$$
   可见可以省去两次$\prod _{i=1}^{max(a,b)}i$的求积

复杂度

• 时间复杂度

1. 填表,表格尺寸为$m\ast n$,$\mathcal{O}(m\ast n)$
2. DP优化空间,也要计算每个位置的值,$\mathcal{O}(m\ast n)$
3. 数学公式,计算乘积次数为$m+n-2-max(m-1,n-1)+min(m-1,n-1)$,因此为$\mathcal{O}(m+n)$

• 空间复杂度

1. DP填表,表格尺寸为$m\ast n$,$\mathcal{O}(m\ast n)$
2. DP优化:只记录一行,$\mathcal{O}(n)$
3. 数学公式,每次调用只有几个变量,$\mathcal{O}(1)$

代码

DP-$\mathcal{O}(m\ast n)$时间,$\mathcal{O}(m\ast n)$空间

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        if m == 1 or n == 1:
            return 1
        # 保留整个dp列表
        dp = [[0 for _ in range(n)] for _ in range(m)]
        for i in range(m):
            dp[i][0] = 1
        for j in range(n):
            dp[0][j] = 1
        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]

DP-$\mathcal{O}(m\ast n)$时间,$\mathcal{O}(n)$空间

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        if m == 1 or n == 1:
            return 1
        dp = [1 for _ in range(n - 1)]
        for i in range(m - 1):
            for j in range(n - 1):
                # 只更新这一行
                if j == 0:
                    dp[j] += 1
                else:
                    dp[j] += dp[j - 1]
        return dp[-1]

数学公式法-$\mathcal{O}(m+n)$时间,$\mathcal{O}(1)$空间

def mul_between(n1, n2):
    """n1到n2间的所有自然数的乘积"""
    result = 1
    for n in range(n1, n2 + 1):
        result *= n
    return result
    

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        if m == 1 or n == 1:
            return 1
        return mul_between(max(m, n), m - 1 + n - 1) // mul_between(1, min(m, n) - 1)