Unique Paths II

Unique Paths II - Problem

You are given an m x n integer array grid. There is a robot 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. An obstacle and space are marked as 1 or 0 respectively in grid.

A path that the robot takes cannot include any square that is an obstacle. Return the number of possible unique paths that the robot can take to reach the bottom-right corner.

The testcases are generated so that the answer will be less than or equal to 2 * 10^9.

Input & Output

Example 1 — 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: Right → Down → Down → Right and Down → Down → Right → Right. The obstacle at [1,1] blocks some paths.

Example 2 — Start Blocked

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

› Output: 1

💡 Note: There is 1 way: Down → Right. The obstacle at [0,1] forces us to go down first.

Example 3 — No Obstacles

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

› Output: 2

💡 Note: Without obstacles, there are 2 paths: Right → Down and Down → Right.

Constraints

m == obstacleGrid.length
n == obstacleGrid[i].length
1 ≤ m, n ≤ 100
obstacleGrid[i][j] is 0 or 1

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 A Apple 28

The key insight is to use dynamic programming where each cell stores the number of ways to reach it from the start. The optimal approach is 1D DP space optimization which reduces space from O(m×n) to O(n). Time: O(m×n), Space: O(n).

Common Approaches

✓ 2D Dynamic Programming

⏱️ Time: O(m×n) Space: O(m×n)

Build a 2D DP table where dp[i][j] represents number of ways to reach cell (i,j). Fill table bottom-up using the recurrence: dp[i][j] = dp[i-1][j] + dp[i][j-1].

Brute Force Recursion

⏱️ Time: O(2^(m+n)) Space: O(m+n)

Use recursion to explore every possible path from start to end. At each cell, try moving right and down if not blocked by obstacles.

Memoization (Top-Down DP)

⏱️ Time: O(m×n) Space: O(m×n)

Use recursion with memoization to cache results of subproblems. Each cell's result is stored to avoid redundant calculations.

Space Optimized 1D DP

⏱️ Time: O(m×n) Space: O(n)

Since we only need the previous row and current row values, we can optimize space by using a single 1D array that gets updated row by row.

2D Dynamic Programming — Algorithm Steps

Initialize DP table with zeros
Set dp[0][0] = 1 if no obstacle
Fill first row and column
Fill remaining cells using recurrence relation

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[0][0] = 1, fill first row/column

Fill Table

dp[i][j] = dp[i-1][j] + dp[i][j-1]

Result

Return dp[m-1][n-1]

Code -

solution.c — C

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

int solution(int** obstacleGrid, int m, int n) {
    if (m == 0 || n == 0 || obstacleGrid[0][0] == 1) {
        return 0;
    }
    
    int** dp = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        dp[i] = (int*)calloc(n, sizeof(int));
    }
    
    // Initialize first cell
    dp[0][0] = 1;
    
    // Fill first row
    for (int j = 1; j < n; j++) {
        if (obstacleGrid[0][j] == 0) {
            dp[0][j] = dp[0][j-1];
        }
    }
    
    // Fill first column
    for (int i = 1; i < m; i++) {
        if (obstacleGrid[i][0] == 0) {
            dp[i][0] = dp[i-1][0];
        }
    }
    
    // Fill remaining cells
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            if (obstacleGrid[i][j] == 0) {
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
    }
    
    int result = dp[m-1][n-1];
    
    for (int i = 0; i < m; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int m = 0, n = 0;
    int** grid = (int**)malloc(100 * sizeof(int*));
    
    char* token = strtok(line, "[],");
    int row = 0, col = 0;
    
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] >= '0' && token[0] <= '9') {
            if (col == 0) {
                grid[row] = (int*)malloc(100 * sizeof(int));
            }
            grid[row][col] = atoi(token);
            col++;
            if (row == 0) n = col;
        }
        token = strtok(NULL, "[],");
        if (token == NULL || (strlen(token) == 0)) {
            if (col > 0) {
                row++;
                col = 0;
            }
        }
    }
    m = row;
    
    int result = solution(grid, m, n);
    printf("%d\n", result);
    
    for (int i = 0; i < m; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Single pass through all cells in the grid

✓ Linear Growth

Space Complexity

O(m×n)

DP table stores path count for each cell

⚡ Linearithmic Space

78.5K Views

High Frequency

~25 min Avg. Time

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

2D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler