Maze Solver - Problem

Given a 2D grid representing a maze where 0 represents an open path and 1 represents a wall, find a path from the top-left corner (0,0) to the bottom-right corner (rows-1, cols-1).

If a valid path exists, return the path as a list of coordinates in the format [[row1,col1], [row2,col2], ...]. If no path exists, return an empty list [].

Movement Rules: You can only move in 4 directions: up, down, left, right (no diagonal movement).

Input & Output

Example 1 — Basic 3x3 Maze

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

› Output: [[0,0],[1,0],[2,0],[2,1],[2,2]]

💡 Note: Path goes down from (0,0) to (1,0) to (2,0), then right to (2,1) and finally (2,2). Cannot go through walls (1s).

Example 2 — Blocked Path

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

› Output: []

💡 Note: No valid path exists from top-left to bottom-right due to walls blocking all possible routes.

Example 3 — Single Cell

$ Input: maze = [[0]]

› Output: [[0,0]]

💡 Note: Single open cell - start and end are the same position, so path contains just that coordinate.

Constraints

1 ≤ maze.length, maze[i].length ≤ 100
maze[i][j] is 0 or 1
maze[0][0] and maze[m-1][n-1] are guaranteed to be 0

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Facebook 18

The key insight is using backtracking to systematically explore all possible paths while marking visited cells to avoid cycles. DFS backtracking finds any valid path by trying each direction recursively and backtracking when hitting dead ends. BFS approach guarantees the shortest path by exploring level-by-level. Time: O(4^(m×n)) for DFS, O(m×n) for BFS. Space: O(m×n).

Common Approaches

✓ BFS Path Finding

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

Use a queue to explore cells level by level, guaranteeing the shortest path. Store parent information to reconstruct the path once destination is reached.

DFS Backtracking

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

Start from (0,0) and recursively explore all four directions. Mark cells as visited during exploration and unmark them when backtracking. If we reach the destination, return the path.

BFS Path Finding — Algorithm Steps

Initialize queue with starting position (0,0)
For each position, explore all 4 neighboring directions
Mark visited cells and store parent information
Continue until destination is reached or queue is empty
Reconstruct path by following parent pointers backward

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with (0,0) in queue, mark as visited

Explore Level

Process all cells at current distance level

Add Neighbors

Add valid unvisited neighbors to queue with parent info

Continue Levels

Process next level until destination found

Reconstruct Path

Follow parent pointers backward to build path

Code -

solution.c — C

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

#define MAX_SIZE 100
#define MAX_QUEUE 10000

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

typedef struct {
    int row, col;
} Point;

void solution(int maze[MAX_SIZE][MAX_SIZE], int rows, int cols) {
    if (maze[0][0] == 1 || maze[rows-1][cols-1] == 1) {
        printf("[]\n");
        return;
    }
    
    if (rows == 1 && cols == 1) {
        printf("[[0,0]]\n");
        return;
    }
    
    Point queue[MAX_QUEUE];
    int front = 0, rear = 0;
    bool visited[MAX_SIZE][MAX_SIZE] = {false};
    Point parent[MAX_SIZE][MAX_SIZE];
    bool hasParent[MAX_SIZE][MAX_SIZE] = {false};
    
    queue[rear++] = (Point){0, 0};
    visited[0][0] = true;
    
    while (front < rear) {
        Point curr = queue[front++];
        
        for (int i = 0; i < 4; i++) {
            int newRow = curr.row + directions[i][0];
            int newCol = curr.col + directions[i][1];
            
            if (newRow >= 0 && newRow < rows && newCol >= 0 && newCol < cols &&
                !visited[newRow][newCol] && maze[newRow][newCol] == 0) {
                visited[newRow][newCol] = true;
                parent[newRow][newCol] = curr;
                hasParent[newRow][newCol] = true;
                queue[rear++] = (Point){newRow, newCol};
                
                if (newRow == rows-1 && newCol == cols-1) {
                    // Reconstruct path
                    Point path[MAX_SIZE*MAX_SIZE];
                    int pathLen = 0;
                    Point currPoint = {rows-1, cols-1};
                    
                    while (true) {
                        path[pathLen++] = currPoint;
                        if (!hasParent[currPoint.row][currPoint.col]) break;
                        currPoint = parent[currPoint.row][currPoint.col];
                    }
                    
                    // Print reversed path
                    printf("[");
                    for (int j = pathLen-1; j >= 0; j--) {
                        printf("[%d,%d]", path[j].row, path[j].col);
                        if (j > 0) printf(",");
                    }
                    printf("]\n");
                    return;
                }
            }
        }
    }
    
    printf("[]\n");
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int maze[MAX_SIZE][MAX_SIZE];
    int rows = 0, cols = 0;
    
    // Simple parsing for [[0,0,1],[0,0,0],[1,0,0]] format
    char* ptr = line + 1; // Skip first [
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            cols = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    maze[rows][cols] = *ptr - '0';
                    cols++;
                }
                ptr++;
            }
            rows++;
        }
        ptr++;
    }
    
    solution(maze, rows, cols);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Each cell is visited at most once, where m and n are maze dimensions

✓ Linear Growth

Space Complexity

O(m×n)

Queue can hold up to m×n cells, plus visited array and parent tracking

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

850 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

Maze Solver - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS Path Finding — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler