Codestin Search App

Unique Paths II - Problem

Imagine a robot starting at the top-left corner of an m × n grid, trying to reach the bottom-right corner. The robot can only move right or down at each step - no diagonal moves allowed!

Here's the twist: some cells in the grid contain obstacles (marked as 1) that block the robot's path, while empty spaces are marked as 0. The robot must navigate around these obstacles.

Your mission: Calculate how many different unique paths the robot can take to reach its destination while avoiding all obstacles.

Example: In a 3×3 grid with an obstacle in the middle, the robot might have multiple ways to reach the goal by going around the obstacle.

Input & Output

example_1.py — Basic Grid with Obstacle

$ Input: obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]

› Output: 2

💡 Note: There are 2 ways to reach the bottom-right corner: 1) Right → Right → Down → Down, 2) Down → Down → Right → Right. The path Right → Down → Right → Down is blocked by the obstacle.

example_2.py — Single Cell with Obstacle

$ Input: obstacleGrid = [[0,1],[0,0]]

› Output: 1

💡 Note: Only one path exists: Down → Right. The path Right → Down is blocked by the obstacle in the top-right corner.

example_3.py — Starting Position Blocked

$ Input: obstacleGrid = [[1]]

› Output: 0

💡 Note: The robot cannot move because the starting position itself is blocked by an obstacle.

Constraints

m == obstacleGrid.length
n == obstacleGrid[i].length
1 ≤ m, n ≤ 100
obstacleGrid[i][j] is 0 or 1
The testcases are generated so that the answer will be less than or equal to 2 × 10⁹

Visualization

Tap to expand

Understanding the Visualization

Setup

Robot starts at top-left, needs to reach bottom-right

Movement Rules

Can only move right (→) or down (↓), never backward

Obstacles

Blocked cells (marked 1) cannot be entered

Path Counting

Count all unique valid routes to destination

Key Takeaway

🎯 Key Insight: Use dynamic programming to build up the solution - each cell's path count equals the sum of paths from the cell above and the cell to the left, unless blocked by obstacles.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28 Apple 22

The optimal solution uses Dynamic Programming with O(m×n) time complexity. Build a DP table where each cell stores the number of ways to reach it from the start. The key insight is that dp[i][j] = dp[i-1][j] + dp[i][j-1] unless the cell contains an obstacle. This approach efficiently avoids recalculating the same subproblems multiple times.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(m×n)	O(m×n)	Build solution bottom-up using memoization to avoid recalculating paths
Recursive Exploration	O(2^(m+n))	O(m+n)	Recursively explore all possible paths from start to end

Dynamic Programming (Optimal) — Algorithm Steps

Create a DP table with same dimensions as the grid
Initialize first cell as 1 if not an obstacle, 0 otherwise
For each cell, if it's not an obstacle, add paths from top and left cells
If cell is an obstacle, set dp[i][j] = 0
Return dp[m-1][n-1] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[0][0] = 1 if no obstacle at start

Fill Row by Row

For each cell, add paths from top and left

Handle Obstacles

Set dp[i][j] = 0 for obstacle cells

Final Answer

dp[m-1][n-1] contains total unique paths

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int uniquePathsWithObstacles(int** obstacleGrid, int rows, int cols) {
    if (rows == 0 || cols == 0 || obstacleGrid[0][0] == 1) {
        return 0;
    }
    
    int** dp = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        dp[i] = (int*)calloc(cols, sizeof(int));
    }
    
    // Initialize starting position
    dp[0][0] = 1;
    
    // Fill the DP table
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (obstacleGrid[i][j] == 1) {
                dp[i][j] = 0;
            } else if (i == 0 && j == 0) {
                continue; // Already initialized
            } else {
                // Add paths from top and left
                if (i > 0) dp[i][j] += dp[i-1][j];
                if (j > 0) dp[i][j] += dp[i][j-1];
            }
        }
    }
    
    int result = dp[rows-1][cols-1];
    
    // Free memory
    for (int i = 0; i < rows; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Visit each cell exactly once to compute the number of paths

✓ Linear Growth

Space Complexity

O(m×n)

Need a 2D DP table to store path counts for each cell

⚡ Linearithmic Space

89.2K Views

High Frequency

~18 min Avg. Time

3.4K 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

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler