Profile DP Grid Paths - Problem

You are given an m x n grid where some cells may contain obstacles. You start at the top-left corner (0, 0) and want to reach the bottom-right corner (m-1, n-1).

You can only move right or down at any point in time. An obstacle is represented by 1 and an empty cell is represented by 0.

Count the number of unique paths from the start to the destination. This problem extends to broken profiles where certain row configurations may be invalid due to obstacles creating disconnected regions.

Use Profile Dynamic Programming with bitmasks to efficiently track valid row states and transitions between adjacent rows.

Input & Output

Example 1 — Basic Grid with Obstacle

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

› Output: 2

💡 Note: Two paths: (0,0)→(0,1)→(0,2)→(1,2)→(2,2) and (0,0)→(1,0)→(2,0)→(2,1)→(2,2). Cannot go through the obstacle at (1,1).

Example 2 — Path Blocked

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

› Output: 0

💡 Note: No valid path exists. Starting at (0,0), we cannot move right due to obstacle at (0,1) and cannot move down due to obstacle at (1,0).

Example 3 — No Obstacles

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

› Output: 2

💡 Note: Two paths: (0,0)→(0,1)→(1,1) and (0,0)→(1,0)→(1,1). Classic grid path counting without obstacles.

Constraints

1 ≤ m, n ≤ 100
grid[i][j] is 0 or 1
grid[0][0] = grid[m-1][n-1] = 0

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 M Microsoft 31 f Facebook 29

The key insight is to use profile dynamic programming with bitmasks to efficiently track row states and valid transitions. For simple grids, 2D DP works well with Time: O(m×n), Space: O(m×n). For complex obstacle patterns, Profile DP with bitmasks provides optimal solution with Time: O(m×2^n×2^n), Space: O(2^n).

Common Approaches

✓ 2D Dynamic Programming

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

Create a 2D DP table where dp[i][j] represents the number of ways to reach cell (i,j). Fill the table row by row, where each cell's value is the sum of paths from the cell above and the cell to the left.

Brute Force Recursion

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

Try every possible path from start to end by recursively exploring right and down moves. Each cell explores all remaining possibilities, leading to exponential time complexity.

Profile DP with Bitmask

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

Advanced technique using profile dynamic programming. Each row's reachable cells are represented as a bitmask. Track valid transitions between row profiles to efficiently count paths through complex obstacle patterns.

2D Dynamic Programming — Algorithm Steps

Initialize DP table with zeros
Set dp[0][0] = 1 if no obstacle
For each cell, if not obstacle: dp[i][j] = dp[i-1][j] + dp[i][j-1]
Handle obstacles by setting dp[i][j] = 0
Return dp[m-1][n-1]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[0][0] = 1

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** grid, int m, int n) {
    if (m == 0 || n == 0 || grid[0][0] == 1) {
        return 0;
    }
    if (grid[m-1][n-1] == 1) {
        return 0;
    }
    
    int** dp = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        dp[i] = (int*)calloc(n, sizeof(int));
    }
    dp[0][0] = 1;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 1) {
                dp[i][j] = 0;
            } else {
                if (i > 0) {
                    dp[i][j] += dp[i-1][j];
                }
                if (j > 0) {
                    dp[i][j] += dp[i][j-1];
                }
            }
        }
    }
    
    int result = dp[m-1][n-1];
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    // Simplified parsing - assume 3x3 grid for demo
    int m = 3, n = 3;
    int** grid = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
    }
    
    // Read grid values
    char line[1000];
    fgets(line, sizeof(line), stdin);
    // Simple manual parsing for [[0,0,0],[0,1,0],[0,0,0]]
    sscanf(line, "[[%d,%d,%d],[%d,%d,%d],[%d,%d,%d]]", 
           &grid[0][0], &grid[0][1], &grid[0][2],
           &grid[1][0], &grid[1][1], &grid[1][2],
           &grid[2][0], &grid[2][1], &grid[2][2]);
    
    int result = solution(grid, m, n);
    printf("%d\n", result);
    
    // Free memory
    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 one value for each grid cell

⚡ Linearithmic Space

78.0K Views

High Frequency

~35 min Avg. Time

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

Profile DP Grid Paths - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

2D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler