[leet code] Unique Paths

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.

=============

Analysis:

Similar problem as Minimum Path Sum.  Actually, this problem is even easier because we don't need to compare the value of each path.  Therefore, two approaches can be used in this problem, i.e. recursive approach (time limit excessed) and iteration approach.  Algorithms of which can be referred to Minimum Path Sum.

Recursive:

public class Solution {
	static int count;
	public static int uniquePaths(int m, int n) {
		if (m == 0 || n == 0)
			return 0;
		if (m == 1 || n == 1)
			return 1;

		count = 0;
		helper(m, n, 0, 0);
		return count;
	}

	public static void helper(int m, int n, int row, int col) {
		// exit: robot reached the bottom-right corner
		if (row == m - 1 && col == n - 1) {
			count++;
			return;
		}

		// case1: robot at the bottom
		if (row == m - 1) {
			helper(m, n, row, col + 1);
		}

		// case2: robot at the right most
		if (col == n - 1) {
			helper(m, n, row + 1, col);
		}

		// case3: robot in the grid body
		if (row != m - 1 && col != n - 1) {
			helper(m, n, row, col + 1);
			helper(m, n, row + 1, col);
		}

		return;
	}
}

 Iteration approach: 

public class Solution {
    public int uniquePaths(int m, int n) {
        if(m==0 || n==0) return 0;
        if(m ==1 || n==1) return 1;
        
        int[][] path = new int[m][n];
        
        // 1st row only 1 path
        for (int i=0; i<n; i++)
            path[0][i] = 1;
        
        // 1st column only 1 path
        for (int i=0; i<m; i++)
            path[i][0] = 1;
        
        // for each body node, number of path = paths from top + paths from left
        for (int i=1; i<m; i++){
            for (int j=1; j<n; j++){
                path[i][j] = path[i-1][j] + path[i][j-1];
            }
        }
        
        return path[m-1][n-1];
    }
}

Basic idea: Construct a m*n grid to hold the number of paths up to current element in the original grid.  Due to the robot can move only to right or down, there are only one path through out the first row and first column.  For the elements which are not in the first row or fist column, its previous element can be from top, or from left.  Therefore, the number of paths up to this element is adding paths from top and paths from left.  For example:

1	1	1
1	2	3
1	3	6

Newly constructed 3*3 path grid corresponding to the 3*3 original grid.

Elements in 1 row and 1 column are all initiated to 1, because there can only be 1 path respectively.

For the element path[1][1], it equals to the number of paths from its top path[0][1] + the number of paths from its left path[1][0].