62. Unique Paths

题目：

A robot is located at the top-left corner of a m x ngrid (marked 'Start' in the diagram below).

The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).

How many possible unique paths are there?

Above is a 3 x 7 grid. How many possible unique paths are there?

Note: m and n will be at most 100.

链接： http://leetcode.com/problems/unique-paths/

题解： 

dp的经典问题，每次向右或向下走一步。第一行或者第一列走到头只有一种方法，所以初始化为1，转移方程是dp[i][j] = dp[i - 1][j] + dp[i][j - 1]

Time Complexity O(m * n)， Space Complexity O(m * n)。

public class Solution {
    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 j = 0; j < n; j ++)
            dp[0][j] = 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];
    }
}

 

Update:

public class Solution {
    public int uniquePaths(int m, int n) {
        if(m == 0 || m == 0)
            return 0;
        int[][] dp = new int[m][n];
        
        for(int i = 0; i < m; i++)      // initialize first column
            dp[i][0] = 1;
            
        for(int j = 1; j < n; j++)      // initialize first row
            dp[0][j] = 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];
    }
}

 

二刷：

Java:

经典的dp，据说还可以用Math来做。我们还是使用dp。

2D DP:

建立一个m x n矩阵，初始化第一条边和第一列为1，然后利用转移方程res[i][j] = res[i - 1][j] + res[i][j - 1]，最后返回res[m - 1][n - 1]

Time Complexity - O(mn)， Space Complexity - O(mn)

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

 

1D DP with rolling array:

对这种简单的DP，一般我们可以用rolling array来减少空间复杂度。我们建立一个长度为n的array，先初始化其中每个元素的值为1，然后在遍历m x n的时候，转移方程简化为 res[j] += res[j - 1]， 还是之前res[i][j]左边和上边的元素。这样节约了一点空间。

Time Complexity - O(mn)， Space Complexity - O(n)

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

 

三刷:

Java:

2D dp:

public class Solution {
    public int uniquePaths(int m, int n) {
        if (m < 0 || n < 0) return 0;
        int[][] dp = new int[m][n];
        for (int i = 0; i < m; i++) dp[i][0] = 1;
        for (int j = 1; j < n; j++) dp[0][j] = 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];
    }
}

 

 

Rolling array 1:

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

 

Rolling array2: 现在才能领会到为什么我们有的时候建立dp数组要用int[] dp = new int[n + 1]。  多增加一个长度的话是为了写的时候不用对第一行赋初值，看起来比较简练，但其实时间复杂度还是一样的。

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

 

Reference:

https://leetcode.com/discuss/9110/my-ac-solution-using-formula

https://leetcode.com/discuss/47829/math-solution-o-1-space