[LintCode] Unique Paths

A robot is located at the top-left corner of a m x n grid.

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.

How many possible unique paths are there?

m and n will be at most 100.

Example

Given m = 3 and n = 3, return 6.
Given m = 4 and n = 5, return 35.

 

Solution 1. Recursion

at any given point (x, y), f(x, y) = f(x + 1, y) + f(x, y + 1), we can form a dfs recursive solution using this formula. 

This recursive solution has overlapping problems. 

pathsTo(m, n) = pathsTo(m - 1, n) + pathsTo(m, n - 1);

pathsTo(m - 1, n) = pathsTo(m - 2, n) + pathsTo(m - 1, n - 1);

pathsTo(m, n - 1) = pathsTo(m, n - 2) +  pathsTo(m - 1, n - 1);

public class Solution {
    private int paths = 0;
    public int uniquePaths(int m, int n) {
        dfs(m - 1, n - 1, 0, 0);
        return paths;
    }
    private void dfs(int dstX, int dstY, int currX, int currY){
        if(currX == dstX && currY == dstY){
            paths++;
            return;
        }
        if(currX > dstX || currY > dstY){
            return;
        }
        dfs(dstX, dstY, currX + 1, currY);
        dfs(dstX, dstY, currX, currY + 1);
    }
}

 

Solution 2. Dynamic Programming, O(m * n) runtime, O(m * n) space

State: f[i][j] : the number of different paths from (0, 0) to (i, j)

Function: f[i][j] = f[i][j - 1] + f[i - 1][j]; 

Initialization: f[i][0] = 1, f[0][j] = 1. 

Answer: f[m - 1][n - 1]

 

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

 

Solution 3. Dynamic Programming with space optimization, O(m * n) runtime, O(n) space

Based on the state function, we know that to compute the current row's results, we only need the results from the previous and the current rows. So we can use rolling array to optimize the space complexity to O(n).

 

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

 

 

Related Problems

Unique Paths II

Unique Paths III