62. Unique Paths

Medium

Problem Description

There is a robot on an m x n grid. The robot is initially located at the top-left corner (i.e., grid[0][0]). The robot tries to move to the bottom-right corner (i.e., grid[m-1][n-1]). The robot can only move either down or right at any point in time.

Given the two integers m and n, return the number of possible unique paths that the robot can take to reach the bottom-right corner.

Examples

Example 1:
Input: m = 3, n = 7
Output: 28

Example 2:
Input: m = 3, n = 2
Output: 3
Explanation: From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:
1. Right -> Down -> Down
2. Down -> Down -> Right
3. Down -> Right -> Down
Jump to Solution: Python Java C++ JavaScript C#

Python Solution


def uniquePaths(m: int, n: int) -> int:
    # Initialize dp array
    dp = [[1] * n for _ in range(m)]
    
    # Fill dp array
    for i in range(1, m):
        for j in range(1, n):
            dp[i][j] = dp[i-1][j] + dp[i][j-1]
    
    return dp[m-1][n-1]

Java Solution


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

C++ Solution


class Solution {
public:
    int uniquePaths(int m, int n) {
        // Initialize dp array
        vector> dp(m, vector(n, 1));
        
        // Fill dp array
        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];
    }
};

JavaScript Solution


/**
 * @param {number} m
 * @param {number} n
 * @return {number}
 */
var uniquePaths = function(m, n) {
    // Initialize dp array
    const dp = Array(m).fill().map(() => Array(n).fill(1));
    
    // Fill dp array
    for (let i = 1; i < m; i++) {
        for (let j = 1; j < n; j++) {
            dp[i][j] = dp[i-1][j] + dp[i][j-1];
        }
    }
    
    return dp[m-1][n-1];
};

C# Solution


public class Solution {
    public int UniquePaths(int m, int n) {
        // Initialize dp array
        int[,] dp = new int[m,n];
        
        // Initialize first row and column
        for (int i = 0; i < m; i++) {
            dp[i,0] = 1;
        }
        for (int j = 0; j < n; j++) {
            dp[0,j] = 1;
        }
        
        // Fill dp array
        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];
    }
}

Complexity Analysis

Solution Explanation

This solution uses dynamic programming to solve the problem:

Key points: