leetcode62. Unique Paths-绝对精品-多种解法-python版

原题

恕我直言，这道题做的十分的爽，解法千变万化，不知是哪位神人出的？

解法一：（虽然跑不出来，但是依然要贴上）
递归版，但数据量大时leetcode上run会失败。

class Solution:
    def uniquePaths(self, m: 'int', n: 'int') -> 'int':
        if m==1 or n==1:
            return 1
        else:
            return self.uniquePaths(m, n-1) + self.uniquePaths(m-1, n)

解法二：空间换时间（貌似也换不了多少时间）
采用一个M*N的二维数组，第一行和第一列均为1，因为到达其位置的路径只有一种。那么到达[i, j]位置的路径有[i-1,j]+[i,j-1]种。

class Solution:
    def uniquePaths(self, m: 'int', n: 'int') -> 'int':
        num_L = []
        for i in range(m):
            num_L.append([])
        for i in range(0, n):
            num_L[0].append(1)
        for i in range(1, m): 
            num_L[i].append(1)
        for i in range(1, m):
            for j in range(1, n):
                num_L[i].append(num_L[i-1][j]+num_L[i][j-1])
        return num_L[m-1][n-1]

解法三：
这种方法要细说。以题目中的例子为例，让我们仔细想一想，当格子的长宽为3*7时，

我们要往下两步，往右六步，往下或是往右互不干涉。这不就是八个数的全排列吗？只不过这八个数里相同的数很多而已，全排列请参考这个。
但没想到的是，利用这种解法依然时间超出限制。本以为这还是一种比较好的解法，但是依然行不通，看来带有递归形式的解法可能不适于这题的求解。

解法四：
上面的一个解法没有解决问题很是令我失望，按常理这里题目肯定还会有更好的解法。回顾之前的解法二，空间上是否可以缩的更小呢？解法二中采用了二维数组的方法，主要是来存储之前已经计算过的值。具体来讲，便是用当前位置上面和左面的值来计算当前的值，实际上每次运算的过程只需要两行的存储空间，这样的话便可以对解法二进行改进！

class Solution:
    def uniquePaths(self, m: 'int', n: 'int') -> 'int':
        if m > n:
            self.uniquePaths(n, m)
        cur = []
        pre = []
        for i in range(m):
            cur.append(1)
            pre.append(1)
        for i in range(1, n):
            for j in range(1, m):
                cur[j] = cur[j-1]+pre[j]
            pre, cur = cur, pre
        return pre[m-1]

嗯！时间复杂度上终于算可以了，但是空间上依然消耗很大，肯定还有别的方法！
解法五：
继续观察上面的解法四，可以看到每次更新cur[i]位置的值时，需要用到cur[i-1]和pre[i]，试问这时的pre是怎么来的，对，没错，就是之前的cur。如果我们不更换cur和pre的话，当前cur[i]的值=cur[i]（更换后的pre）+cur[i-1]。不说了，上代码：

class Solution:
    def uniquePaths(self, m: 'int', n: 'int') -> 'int':
        if m > n:
            self.uniquePaths(n, m)
        cur = []
        for i in range(m):
            cur.append(1)
        for i in range(1, n):
            for j in range(1, m):
                cur[j] += cur[j-1]
        return cur[m-1]

但是很令人费解的是，即使是这样，时间复杂度也只是beat了70%的人，不应该啊！

后来在某贴上看到公式大法：

class Solution:
    # @return an integer
    def uniquePaths(self, m, n):
        aux = [[1 for x in range(n)] for x in range(m)]
        for i in range(1, m):
            for j in range(1, n):
                aux[i][j] = aux[i][j-1]+aux[i-1][j]
        return aux[-1][-1]

不得不说，还是公式好！