The Maze - Practice Coding Problems

The Maze - Problem

The Maze - A Rolling Ball Adventure! 🎳

Imagine a ball rolling through a maze with a unique twist: the ball cannot stop until it hits a wall! This creates an interesting pathfinding challenge where you must think several steps ahead.

Problem: Given an m x n maze where 0 represents empty spaces and 1 represents walls, determine if a ball can reach its destination. The ball starts at position [startrow, startcol] and needs to reach [destinationrow, destinationcol].

Key Rules:
• The ball rolls in one direction until it hits a wall
• Only when stopped can it choose a new direction
• The maze borders are surrounded by walls
• Return true if the destination is reachable, false otherwise

Example: If the ball rolls right, it continues rolling right through all empty spaces until it hits a wall, then stops at the last empty space before the wall.

Input & Output

example_1.py — Basic Maze

$ Input: maze = [[0,0,1,0,0],[0,0,0,0,0],[0,0,0,1,0],[1,1,0,1,1],[0,0,0,0,0]] start = [0,4] destination = [4,4]

› Output: true

💡 Note: The ball can roll from start [0,4] down to [1,4], then left to [1,0], then down to [4,0], and finally right to reach destination [4,4].

example_2.py — Blocked Path

$ Input: maze = [[0,0,1,0,0],[0,0,0,0,0],[0,0,0,1,0],[1,1,0,1,1],[0,0,0,0,0]] start = [0,4] destination = [3,2]

› Output: false

💡 Note: The destination [3,2] is unreachable because there's no way for the ball to stop at that position - it would always roll past it or be blocked by walls.

example_3.py — Same Start and Destination

$ Input: maze = [[0,0,0,0,0],[1,1,0,0,1],[0,0,0,0,0],[0,1,0,0,1],[0,1,0,0,0]] start = [0,0] destination = [0,0]

› Output: true

💡 Note: When start and destination are the same position, the ball is already at the target, so the answer is true.

Constraints

m == maze.length
n == maze[i].length
1 ≤ m, n ≤ 100
maze[i][j] is 0 or 1
start.length == 2
destination.length == 2
0 ≤ start_row, destination_row < m
0 ≤ start_col, destination_col < n
Both the start and destination positions are empty spaces
The borders of the maze are all walls

Visualization

Tap to expand

Understanding the Visualization

Start Rolling

Ball begins at starting position and can roll in 4 directions

Continuous Motion

Once rolling, ball continues until hitting a wall - cannot stop mid-roll

Mark Stopping Points

Track where ball stops to avoid revisiting same positions

Explore All Paths

From each stopping point, try rolling in all four directions

Find Destination

Success when ball stops exactly at destination coordinates

Key Takeaway

🎯 Key Insight: The ball can only stop when it hits a wall, so we only need to track stopping positions, not every cell the ball rolls through. This dramatically reduces the search space and makes the problem tractable with simple DFS + visited set tracking.

Asked in

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

The optimal solution uses Depth-First Search (DFS) with a visited set to efficiently explore the maze. The key insight is that the ball rolls continuously in one direction until hitting a wall, so we only track stopping positions rather than every cell the ball passes through. This approach achieves O(m×n) time complexity and avoids infinite loops by marking visited positions.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force DFS (Without Visited Tracking)	O(4^(m*n))	O(m*n)	Naive DFS that explores all paths without tracking visited positions
DFS with Visited Set (Optimal)	O(m*n)	O(m*n)	Efficient DFS using a visited set to track explored positions and avoid infinite loops

Brute Force DFS (Without Visited Tracking) — Algorithm Steps

Start from the initial position
For each direction (up, down, left, right), roll the ball until it hits a wall
If we reach the destination, return true
Recursively explore from each stopping position
Return false if no path leads to destination

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Begin DFS from starting position

Roll in Direction

Roll ball until hitting wall in each direction

Recursive Exploration

Recursively explore from each stopping position

Potential Loops

May revisit same positions multiple times

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

bool dfs(int maze[][100], int rows, int cols, int x, int y, int destX, int destY) {
    if (x == destX && y == destY) {
        return true;
    }
    
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
    for (int i = 0; i < 4; i++) {
        int nx = x, ny = y;
        int dx = directions[i][0], dy = directions[i][1];
        
        while (nx + dx >= 0 && nx + dx < rows && 
               ny + dy >= 0 && ny + dy < cols && 
               maze[nx + dx][ny + dy] == 0) {
            nx += dx;
            ny += dy;
        }
        
        if (nx != x || ny != y) {
            if (dfs(maze, rows, cols, nx, ny, destX, destY)) {
                return true;
            }
        }
    }
    
    return false;
}

int main() {
    // Input parsing and solution call would be implemented here
    printf("true\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^(m*n))

In worst case, we might explore 4 directions from each cell multiple times without proper visited tracking

✓ Linear Growth

Space Complexity

O(m*n)

Recursion stack can go as deep as the number of cells in the maze

⚡ Linearithmic Space

42.5K Views

Medium Frequency

~25 min Avg. Time

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

Brute Force DFS (Without Visited Tracking) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler