Unique Paths Java

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?

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

Note: m and n will be at most 100.

There are 3 Approaches to solve this problem

1. Naive Solution: Recursion 

This is most obviously one, but not good enough to AC in LeetCode

 public int uniquePathsNaive(int m, int n) {

        return helper(1,1,m,n);
    }
    private static int helper(int i,int j,int m,int n){
        if(i>m || j>n) return 0;
        if(i==m && j==n) return 1;

        return helper(i+1,j,m,n) +helper(i,j+1,m,n);
    }

2.  Better Solution:

Key to solve: DP
    The robot can only move down or right =>
   And the DP formula: res[i][j] =res[i-1][j]+res[i][j-1]

Time: O(m*n) Space:(m*n)

 public static int uniquePathsDP2(int m, int n) {
        //special case
        if(m==0 && n==0) return 0;
        int[][] result=new int[m][n];
        for(int i=0;i<m;i++){
            result[i][0]=1;
        }
        for (int j=0;j<n;j++){
            result[0][j]=1;
        }
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                result[i][j]=result[i-1][j]+result[i][j-1];
            }
        }
        return result[m-1][n-1];
    }

Another way to solve in DP, we only need 1D array in size of column to store  value of previous row,

     As a result, the last grid will be total of Unique Paths
     Time: O(m*n)
     Space: O(n)

public int uniquePathsDP(int m, int n) {
        //special case
        if(m==0 && n==0) return 0;
        int[] result=new int[n];
        result[0]=1;
        for(int i=0;i<m;i++){
            for(int j=1;j<n;j++){
                result[j]+=result[j-1];
            }
        }
        return result[n-1];
   }

3. Best Solution: 

Covert it into Combination problem
    total steps to reach the from left-top to right-bottom is(m-1)+(n-1)
    use m-1 steps
    Thus: calculate C(m+n-2, m-1)
    Time: O(min(m,n))   Space: O(1)

public int uniquePaths(int m, int n) {
        double denominator=1;
        double domain=1;
        int small,big;
        if(m<n) {
            small = m - 1;
            big = n - 1;
        }
        else{
            small=n-1;
            big=m-1;
        }
        for(int i=1;i<=small;i++){
            denominator=denominator*i;
            domain=domain*(small+big+1-i);
        }
        return (int)(domain/denominator);
    }