Unique Paths III - Practice Coding Problems

Unique Paths III - Problem

🎯 Grid Path Explorer Challenge

Imagine you're a robot explorer navigating a mysterious grid-based terrain. Your mission is to find all possible paths from your starting position to the target destination with one crucial constraint: you must visit every accessible square exactly once!

You're given an m × n integer grid where each cell represents:

1 - Your starting square (exactly one exists)
2 - The ending square (exactly one exists)
0 - Empty squares you can walk over
-1 - Obstacles that block your path

Goal: Return the number of unique 4-directional walks from start to end that visit every non-obstacle square exactly once.

Example: In a 3×3 grid with start at (0,0), end at (2,2), and one obstacle, you might find 4 different valid paths that cover all walkable squares.

Input & Output

example_1.py — Basic Grid

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

› Output: 2

💡 Note: There are exactly 2 paths that visit every walkable square exactly once and end at the target. Both paths start from (0,0), visit all zeros, and end at (2,2).

example_2.py — Simple Path

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

› Output: 4

💡 Note: With no obstacles, there are 4 different ways to traverse all squares exactly once from start to end, considering different path combinations.

example_3.py — No Valid Path

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

› Output: 0

💡 Note: There's no valid path because we cannot visit all walkable squares exactly once due to the grid layout constraints.

Visualization

Tap to expand

Understanding the Visualization

Scout the Territory

Count all walkable squares and locate start/end positions

Begin Exploration

Start DFS from the beginning position, trying each direction

Mark Progress

Temporarily mark visited squares to avoid revisiting in current path

Check Victory

When reaching end, verify all walkable squares were visited

Backtrack & Continue

Unmark squares and try alternative routes to find all solutions

Key Takeaway

🎯 Key Insight: Backtracking with state management allows us to systematically explore all possible paths while ensuring we visit every walkable square exactly once

Time & Space Complexity

Time Complexity

⏱️

O(4^(m×n))

In worst case, we explore 4 directions for each of the m×n cells, leading to exponential time complexity

✓ Linear Growth

Space Complexity

O(m×n)

Space for recursion stack and visited array, proportional to grid size

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 20
1 ≤ m × n ≤ 20
grid[i][j] is -1, 0, 1, or 2
There is exactly one starting square and one ending square

Asked in

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

The optimal approach uses backtracking with DFS to systematically explore all possible paths. Key insights: track visited squares by temporarily marking them as obstacles, count walkable squares upfront for validation, and use recursive exploration with proper backtracking to find all valid complete paths.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force DFS with State Tracking	O(4^(m×n))	O(m×n)	Explore all possible paths using recursive DFS with visited state tracking

Brute Force DFS with State Tracking — Algorithm Steps

Find start position and count total walkable squares
Use DFS from start position with visited state
For each cell, try all 4 directions (up, down, left, right)
Mark current cell as visited before recursing
If we reach the end and visited all squares, increment path count
Unmark current cell when backtracking to try other paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Find start position and count walkable squares

Explore

Try each direction from current position

Mark Visited

Temporarily mark current square as obstacle

Check End

If at end and visited all squares, count path

Backtrack

Unmark square and try next direction

Code -

solution.c — C

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

int m, n, emptyCount;
int directions[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};

int dfs(int** grid, int row, int col, int visitedCount) {
    // Base cases
    if (row < 0 || row >= m || col < 0 || col >= n || grid[row][col] == -1) {
        return 0;
    }
    if (grid[row][col] == 2) {
        return visitedCount == emptyCount ? 1 : 0;
    }
    
    // Mark as visited
    int temp = grid[row][col];
    grid[row][col] = -1;
    
    // Explore all 4 directions
    int paths = 0;
    for (int i = 0; i < 4; i++) {
        paths += dfs(grid, row + directions[i][0], col + directions[i][1], visitedCount + 1);
    }
    
    // Backtrack
    grid[row][col] = temp;
    return paths;
}

int uniquePathsIII(int** grid, int gridSize, int* gridColSize) {
    m = gridSize;
    n = gridColSize[0];
    int startRow = 0, startCol = 0;
    emptyCount = 0;
    
    // Find start position and count empty squares
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 1) {
                startRow = i;
                startCol = j;
                emptyCount++;
            } else if (grid[i][j] == 2) {
                emptyCount++;
            } else if (grid[i][j] == 0) {
                emptyCount++;
            }
        }
    }
    
    return dfs(grid, startRow, startCol, 0);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(4^(m×n))

In worst case, we explore 4 directions for each of the m×n cells, leading to exponential time complexity

✓ Linear Growth

Space Complexity

O(m×n)

Space for recursion stack and visited array, proportional to grid size

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 20
1 ≤ m × n ≤ 20
grid[i][j] is -1, 0, 1, or 2
There is exactly one starting square and one ending square

89.2K Views

Medium Frequency

~25 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

🎯 Grid Path Explorer Challenge

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force DFS with State Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler