[LeetCode]Unique Paths

Question
A robot is located at the top-left corner of a m x n grid (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?

本题难度Medium。有3种算法分别是：DFS、DP和一维数组（DP优化版）

1、DFS

【复杂度】
时间 O(N！) 空间 O(1)

【思路】
利用DFS遍历所有可能。不过这个方法会 Time Limit Exceeded。

【注意】
23行​​​helper(x+1,y,m,n);​​不要写成：

helper(++x,y,m,n);

它会影响25行。

【代码】

public class Solution {
    int count=0;
    public int uniquePaths(int m, int n) {
        //require
        if(m==0||n==0)
            return 1;
        if(m==1||n==1)
            return 1;
        //invariant
        helper(0,0,m,n);
        //ensure
        return count;
    }

    private void helper(int x,int y,int m,int n){
        //base case
        if(x==m-1||y==n-1){
            count++;
            return;
        }

        if(x<m-1)
            helper(x+1,y,m,n);
        if(y<n-1)
            helper(x,y+1,m,n);
    }
}

2、DP

【复杂度】
时间 O(MN) 空间 O(MN)

【思路】
每一步只能向右方或者下方走，所以经过每一个格子路径数只可能源自左方或上方，这就得到了动态规划的递推式，我们用一个二维数组dp储存每个格子的路径数，则​​​dp[i][j]=dp[i-1][j]+dp[i][j-1]​​。最左边和最上边的路径数都固定为1，代表一直沿着最边缘走的路径。

【附】
本题的测试用例中应该没有​​​m=0,n=0​​。

【代码】

public class Solution {
    public int uniquePaths(int m, int n) {
        //require
        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;    
        //invariant
        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];
        //ensure
        return dp[m-1][n-1];
    }
}

3、一维数组

【复杂度】
时间 O(MN) 空间 O(N)

【思路】
实际上我们可以复用每一行的数组来节省空间，每个元素更新前的值都是其在二维数组中对应列的上一行的值。这里​​​dp[i] = dp[i - 1] + dp[i]​​

【注意】
dp[0]一直等于1，因此8行的​​​i​​​与9行的​​j​​​都是从​​1​​​而不是​​0​​开始循环。

【代码】

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

参考

​​[Leetcode] Unique Paths 唯一路径​​