Unique Paths - Practice Coding Problems

Unique Paths - Problem

Robot Path Navigation Problem

Imagine a robot placed at the top-left corner of an m × n grid. This robot has a simple mission: navigate to the bottom-right corner using the most efficient path possible.

The robot has two movement constraints:
• It can only move right (→)
• It can only move down (↓)

Given the grid dimensions m (rows) and n (columns), your task is to calculate the total number of unique paths the robot can take to reach its destination.

Example: In a 3×7 grid, there are 28 different ways to reach from (0,0) to (2,6).

🎯 Goal: Return the number of possible unique paths from top-left to bottom-right corner.

Input & Output

example_1.py — Basic Grid

$ Input: m = 3, n = 7

› Output: 28

💡 Note: In a 3×7 grid, the robot needs to make 2 down moves and 6 right moves (total 8 moves). The number of ways to arrange these moves is C(8,2) = 28.

example_2.py — Square Grid

$ Input: m = 3, n = 2

› Output: 3

💡 Note: In a 3×2 grid, there are only 3 unique paths: right→down→down, down→right→down, and down→down→right.

example_3.py — Edge Case

$ Input: m = 1, n = 1

› Output: 1

💡 Note: In a 1×1 grid, the robot is already at the destination, so there is exactly 1 path (staying put).

Visualization

Tap to expand

Understanding the Visualization

Start Position

Robot begins at top-left corner (0,0)

Movement Rules

Can only move right (→) or down (↓)

Path Counting

Each valid path requires exactly (m-1) down + (n-1) right moves

Mathematical Insight

Total paths = ways to arrange these moves = C(m+n-2, m-1)

Key Takeaway

🎯 Key Insight: This is fundamentally a combinatorial problem about arranging a sequence of moves, not a pathfinding problem!

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

We fill each cell in the m×n grid exactly once

✓ Linear Growth

Space Complexity

O(m*n)

We store the DP table of size m×n

⚡ Linearithmic Space

Constraints

1 ≤ m, n ≤ 100
The answer will be less than or equal to 2 × 10⁹
All inputs are positive integers

Asked in

G Google 45 a Amazon 38 f Meta 29 ⊞ Microsoft 22

The optimal solution uses dynamic programming with O(m×n) time complexity. However, the most elegant approach recognizes this as a combinatorial problem: calculating C(m+n-2, m-1) in O(min(m,n)) time and O(1) space. Both approaches are valid, with DP being more intuitive and combinatorics being more space-efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Exploration	O(2^(m+n))	O(m+n)	Recursively explore all possible paths from current position
Dynamic Programming (Optimal)	O(m*n)	O(m*n)	Build solution bottom-up using memoization to avoid recalculation
Mathematical Combinatorics	O(min(m, n))	O(1)	Use combinatorial formula C(m+n-2, m-1) to calculate directly

Recursive Exploration — Algorithm Steps

Start from position (0, 0)
At each position, check if we can move right or down
If we reach the destination (m-1, n-1), count this as 1 path
If we go out of bounds, return 0 paths
Return sum of paths from moving right + paths from moving down

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at (0,0)

Begin recursive exploration from top-left corner

Branch Right & Down

At each cell, create two recursive branches

Base Cases

Return 1 when reaching destination, 0 when out of bounds

Sum Results

Combine results from all recursive branches

Code -

solution.c — C

#include <stdio.h>

int dfs(int row, int col, int m, int n) {
    // Base case: reached destination
    if (row == m - 1 && col == n - 1) {
        return 1;
    }
    
    // Out of bounds
    if (row >= m || col >= n) {
        return 0;
    }
    
    // Explore right and down
    return dfs(row, col + 1, m, n) + dfs(row + 1, col, m, n);
}

int uniquePaths(int m, int n) {
    return dfs(0, 0, m, n);
}

int main() {
    int m, n;
    scanf("%d %d", &m, &n);
    printf("%d\n", uniquePaths(m, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(m+n))

Each position has 2 choices, creating a binary tree of depth roughly m+n

✓ Linear Growth

Space Complexity

O(m+n)

Recursion stack depth is at most m+n (maximum path length)

⚡ Linearithmic Space

Constraints

1 ≤ m, n ≤ 100
The answer will be less than or equal to 2 × 10⁹
All inputs are positive integers

89.4K Views

High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Recursive Exploration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler