【思路-Java】

採用動態規劃。動態規劃要求利用到上一次的結果，是一種特殊的迭代思想，動態規劃的關鍵是要得到遞推關係式。對於本題，到達某一點的路徑數等於到達它上一點的路徑數與它左邊的路徑數之和。也即，起點到點(i, j)的路徑總數：ways[i][j] = 起點到點(i, j-1)的總數：ways[i][j-1] + 起點到點(i-1, j)總數：ways[i-1][j]。於是我們就得到遞推關係式：ways[i][j] = ways[i][j-1] + ways[i-1][j]

public class Solution {
    public int uniquePaths(int m, int n) {
        int[][] ways = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i == 0 || j == 0) ways[i][j] = 1;
                else ways[i][j] = ways[i-1][j] + ways[i][j-1];
            }
        }
        return ways[m-1][n-1];
    }
}
 

【優化-Java、Python】

這種優化是對上述方法空間的一種優化，使得空間複雜度從原來的 O(n*m)下降為 O(n)。對於起點到點(i,j)的路徑總數：ways[j]= 起點到點(i-1, j) 的路徑總數：ways[j] + 起點到點(i, j-1)的路徑總數 ways[j-1]，於是我們就得到遞推式：ways[j] = ways[j] + ways[j-1]

public class Solution {
    public int uniquePaths(int m, int n) {
        int[] ways = new int[n];
        ways[0] = 1;
        for(int i = 0; i < m; i++)
            for (int j = 1; j < n; j++)
                ways[j] += ways[j-1];
        return ways[n-1];
    }
}
 

61 / 61 test cases passed. Runtime: 0 ms  Your runtime beats 85.40% of javasubmissions.

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

【補充-Java】遞迴實現

用遞迴，但是對大case會超時

    public int uniquePaths(int m, int n) {
        if (m == 1 || n == 1) return 1;
        return uniquePaths(m, n - 1) + uniquePaths(m - 1, n);
    }

有沒有想過為什麼會超時？因為遞迴和迴圈不同，迴圈可以用陣列儲存上一次計算的結果，而遞迴的上一次結果會被銷燬，因而會多出來很多重複的中間計算結果：