一個機器人位於一個 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 64：最小路徑和（最詳細的解法！！！） 很類似，我們同樣可以通過遞迴解決。我們要知道左上角開始有多少路徑，那麼我們只需要知道左上角的→有多少路徑以及↓有多少路徑，然後將兩者相加即可。

class Solution:
    def uniquePaths(self, m, n):
        """
        :type m: int
        :type n: int
        :rtype: int
        """
        return self._uniquePaths(
 
m, n, 0, 0)

    def _uniquePaths(self, m, n, row, col):
        if row == m - 1 or col == n - 1:
            return 1

        return self._uniquePaths(m, n, row + 1, col) +\
                         self._uniquePaths(m, n, row, col + 1)

但是這樣做存在著大量的重複運算（在哪呢？）。我們可以通過記憶化搜尋的方式來優化上面的問題。

class Solution:
    def
 
 uniquePaths(self, m, n):
        """
        :type m: int
        :type n: int
        :rtype: int
        """
        mem = [[None]*m for _ in range(n)]
        return self._uniquePaths(m, n, 0, 0, mem)

    def _uniquePaths(self, m, n, row, col, mem):
        if row == n - 1 or col == m - 1:
            return 1

        if row < n and col < m and mem[row][col]:
            return mem[row][col]

        mem[row][col] = self._uniquePaths(m, n, row + 1, col, mem) +\
                         self._uniquePaths(m, n, row, col + 1, mem)
        return mem[row][col]

同樣的，我們也可以反過來思考問題，直接從終點出發，而不是從起點出發。

class Solution:
    def uniquePaths(self, m, n):
        """
        :type m: int
        :type n: int
        :rtype: int
        """
        mem = [[None]*m for _ in range(n)]
        for i in range(m):
            mem[n - 1][i] = 1
        
        for i in range(n):
            mem[i][m - 1] = 1

        for i in range(n - 2, -1, -1):
            for j in range(m - 2, -1, -1):
                mem[i][j] = mem[i + 1][j] + mem[i][j + 1]

        return mem[0][0]

其實這個問題最簡單的思路是通過排列組合解決，實際上這是一個組合問題。對於一個mxn的網格來說，我們要知道有多少種路徑，那麼只要知道m+n-2個step中，向下的n-1個step有多少種組合即可，也就是$C_{m+n-2}^{n-1}$。

import math 
class Solution:
    def uniquePaths(self, m, n):
        """
        :type m: int
        :type n: int
        :rtype: int
        """
        mole = math.factorial(m)
        deno = math.factorial(n - r) * math.factorial(r)
        return int(mole/deno)  

上述程式碼在使用c++寫的時候存在資料溢位的風險，最好使用long long進行資料儲存。另外，一個最簡單的做法是，使用c++的庫函式lgamma，並且lgamma(n)=log((n-1)!)

#include <math.h>
class Solution 
{
public:
    int uniquePaths(int m, int n) 
    {
        return int(exp(lgamma(m+n-1)-lgamma(m)-lgamma(n))+0.5);
    }
};

如有問題，希望大家指出！！！