不同路徑

一個機器人位於一個 *m x n *網格的左上角 (起始點在下圖中標記為“Start” )。

機器人每次只能向下或者向右移動一步。機器人試圖達到網格的右下角(在下圖中標記為“Finish”)。

問總共有多少條不同的路徑？

例如，上圖是一個7 x 3 的網格。有多少可能的路徑？

示例 1:

輸入: m = 3, n = 2輸出: 3解釋:
從左上角開始，總共有 3 條路徑可以到達右下角。
1. 向右 -> 向右 -> 向下
2. 向右 -> 向下 -> 向右
3. 向下 -> 向右 -> 向右

示例 2:

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

方法一：動態規劃

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

空間優化：
由於當前位置只取決於上一行和當前位置的前一列，所以只需要用一個一維陣列儲存上一行的計算結果，在遍歷每一行的時候得到前一個位置的值

O(2n)：

public int uniquePaths(int m, int n) {
    int[] pre = new int[n];
    int[] cur = new int[n];
    Arrays.fill(pre, 1);
    for (int i =1; i < m; i++) {
        cur[0] = 1;
        for (int j =1; j < n; j++) {
            cur[j] = cur[j - 1] + pre[j];
        }
        pre = cur;
    }
    return pre[n - 1];
}
 

O(n)：

public int uniquePaths(int m, int n) {
    int[] dp = new int[n];
    Arrays.fill(dp, 1);
    int pre = 1;
    for (int i = 1; i < m; i++) {
        pre = 1;
        for (int j = 1; j < n; j++) {
            dp[j] = pre + dp[j];
            pre = dp[j];
        }
    }
    return dp[n - 1];
}

方法二：排列組合(未通過)
m=3, n=2，只要向下 1 步，向右 2 步就一定能到達終點。
所以有 C_{m+n-2}^{m-1}

public int uniquePaths(int m, int n) {
    return (int) (factorial(m + n -2) / factorial(n - 1) / factorial(m - 1));
}

public long factorial(int n) {
    long sum = 1;
    for (int i = 1; i <= n; i++) {
        sum *= i;
    }
    return sum;
}

由於乘積導致溢位，所以未通過

最小路徑和

給定一個包含非負整數的 m x n 網格，請找出一條從左上角到右下角的路徑，使得路徑上的數字總和為最小。

說明：每次只能向下或者向右移動一步。

示例:

輸入:
[
[1,3,1],
[1,5,1],
[4,2,1]
]輸出: 7解釋: 因為路徑 1→3→1→1→1 的總和最小

public int minPathSum(int[][] grid) {
    if (grid == null || grid[0].length == 0) {
        return 0;
    }
    int row = grid.length;
    int col = grid[0].length;
    int[][] dp = new int[row][col];
    dp[0][0] = grid[0][0];
    for (int i = 1; i < col; i++) {
        dp[0][i] = dp[0][i - 1] + grid[0][i];
    }
    for (int i = 1; i < row; i++) {
        dp[i][0] = dp[i - 1][0] + grid[i][0];
    }
    for (int i = 1; i < row; i++) {
        for (int j = 1; j < col; j++) {
            dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
        }
    }
    return dp[row - 1][col - 1];
}

空間優化：

public int minPathSum(int[][] grid) {
    if (grid == null || grid[0].length == 0) {
        return 0;
    }
    int row = grid.length;
    int col = grid[0].length;
    int[] dp = new int[col];
    dp[0] = grid[0][0];
    for (int i = 1; i < col; i++) {
        dp[i] = dp[i - 1] + grid[0][i];
    }
    for (int i = 1; i < row; i++) {
        dp[0] = dp[0] + grid[i][0];
        int pre = dp[0];
        for (int j = 1; j < col; j++) {
            dp[j] = Math.min(dp[j], pre) + grid[i][j];
            pre = dp[j];
        }
    }
    return dp[col - 1];
}