The Maze III - Practice Coding Problems

The Maze III - Problem

Array String Depth-First Search Breadth-First Search Graph Heap (Priority Queue) Matrix Shortest Path Hard

Imagine a rolling ball trapped in a maze with a twist! This ball can't stop on a dime - once it starts rolling in a direction, it keeps going until it hits a wall. Your mission? Guide this ball through the maze to drop into a hole using the shortest path possible.

The maze is represented as an m x n grid where:

0 represents empty spaces
1 represents walls

The ball starts at position ball = [ballrow, ballcol] and needs to reach the hole at hole = [holerow, holecol]. Here's the catch:

🎯 The ball rolls continuously until it hits a wall or falls into the hole
📏 Distance is measured by the number of empty spaces traveled
🔤 If multiple shortest paths exist, return the lexicographically smallest instruction sequence
⚡ Valid moves: 'u' (up), 'd' (down), 'l' (left), 'r' (right)

Return the instruction string for the shortest path, or "impossible" if no path exists.

Input & Output

example_1.py — Basic maze with single path

$ 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]], ball = [4,3], hole = [0,1]

› Output: "lul"

💡 Note: Ball rolls left until hitting wall at (4,0), then up until hitting wall at (0,0), then left to reach hole at (0,1). Total distance: 3+4+1=8 steps with path "lul".

example_2.py — Multiple paths with lexicographical choice

$ 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]], ball = [4,3], hole = [3,0]

› Output: "ul"

💡 Note: Two possible paths: "ul" (up 1 step, left 3 steps = 4 total) and "lu" (left 3 steps, up 1 step = 4 total). Since both have same distance, return lexicographically smaller "ul".

example_3.py — Impossible maze

$ 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]], ball = [4,3], hole = [4,0]

› Output: "impossible"

💡 Note: Ball can reach position (4,0) but cannot stop there because it would roll past the hole, making it impossible to drop into the hole at that exact position.

Constraints

m == maze.length
n == maze[i].length
1 ≤ m, n ≤ 100
maze[i][j] is 0 or 1
ball.length == 2
hole.length == 2
0 ≤ ball_row, hole_row < m
0 ≤ ball_col, hole_col < n
Both the ball and hole exist in an empty space
The maze borders are all walls

Visualization

Tap to expand

Understanding the Visualization

Start Position

Ball begins at starting position, ready to roll in any direction

Roll Until Obstacle

When ball rolls in a direction, it continues until hitting a wall or falling into hole

Calculate Distance

Count the number of empty spaces traveled during each rolling movement

Track Best Path

Keep track of shortest total distance and lexicographically smallest instruction sequence

Priority Queue Processing

Use Dijkstra's algorithm to efficiently explore paths in order of increasing distance

Key Takeaway

🎯 Key Insight: This problem combines shortest path algorithms with string comparison. Using Dijkstra's algorithm with a custom comparator ensures we find the optimal solution efficiently while handling lexicographical ordering requirements.

Asked in

G Google 42 a Amazon 38 f Meta 31 ⊞ Microsoft 25

The optimal approach uses Dijkstra's algorithm with a priority queue that considers both distance and lexicographical ordering. This ensures we find the shortest path, and when multiple shortest paths exist, we return the lexicographically smallest one. The key insight is treating this as a graph problem where nodes are stopping positions and edges represent rolling movements.

Common Approaches

Approach	Time	Space	Notes
✓ Dijkstra's Algorithm with Lexicographical Ordering	O(mn * log(mn))	O(mn)	Use Dijkstra's shortest path algorithm with custom comparison for lexicographical ordering

Dijkstra's Algorithm with Lexicographical Ordering — Algorithm Steps

Initialize priority queue with starting position, distance 0, and empty path
Use custom comparator: prioritize by distance first, then lexicographically by path
For each position popped from queue, try rolling in all four directions
Calculate new position and distance after rolling until hitting wall or hole
If reached hole, return the path; if reached new position, add to queue
Continue until queue is empty or hole is reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Priority Queue

Start with ball position, distance 0, empty path

Process Minimum Distance

Always process the position with smallest distance first

Explore Rolling Directions

Roll in each direction until hitting wall or hole

Update Distances

Add new positions to queue if better path found

Lexicographical Ordering

When distances are equal, prioritize alphabetically smaller paths

Code -

solution.c — C

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

typedef struct {
    int dist;
    char path[1000];
    int x, y;
} State;

typedef struct {
    State* states[10000];
    int size;
} PriorityQueue;

void pq_init(PriorityQueue* pq) {
    pq->size = 0;
}

int compare_states(const State* a, const State* b) {
    if (a->dist != b->dist) return a->dist - b->dist;
    return strcmp(a->path, b->path);
}

void pq_push(PriorityQueue* pq, State* state) {
    int i = pq->size;
    pq->states[i] = state;
    pq->size++;
    
    // Simple insertion sort for priority queue
    while (i > 0 && compare_states(pq->states[i], pq->states[i-1]) < 0) {
        State* temp = pq->states[i];
        pq->states[i] = pq->states[i-1];
        pq->states[i-1] = temp;
        i--;
    }
}

State* pq_pop(PriorityQueue* pq) {
    if (pq->size == 0) return NULL;
    State* result = pq->states[0];
    pq->size--;
    for (int i = 0; i < pq->size; i++) {
        pq->states[i] = pq->states[i+1];
    }
    return result;
}

char* findShortestWay(int** maze, int rows, int cols, int* ball, int* hole) {
    int directions[4][2] = {{1,0}, {0,-1}, {0,1}, {-1,0}};
    char dirChars[4] = {'d', 'l', 'r', 'u'};
    
    PriorityQueue pq;
    pq_init(&pq);
    
    State* start = (State*)malloc(sizeof(State));
    start->dist = 0;
    strcpy(start->path, "");
    start->x = ball[0];
    start->y = ball[1];
    pq_push(&pq, start);
    
    // Simple visited tracking (could be optimized)
    int visited[100][100] = {0}; // Assuming max 100x100 maze
    
    while (pq.size > 0) {
        State* curr = pq_pop(&pq);
        
        if (curr->x == hole[0] && curr->y == hole[1]) {
            char* result = (char*)malloc(strlen(curr->path) + 1);
            strcpy(result, curr->path);
            return result;
        }
        
        if (visited[curr->x][curr->y]) {
            continue;
        }
        visited[curr->x][curr->y] = 1;
        
        for (int i = 0; i < 4; i++) {
            int dx = directions[i][0], dy = directions[i][1];
            char direction = dirChars[i];
            int nx = curr->x, ny = curr->y, steps = 0;
            
            while (nx + dx >= 0 && nx + dx < rows && 
                   ny + dy >= 0 && ny + dy < cols && 
                   maze[nx + dx][ny + dy] == 0) {
                nx += dx;
                ny += dy;
                steps++;
                if (nx == hole[0] && ny == hole[1]) {
                    char* result = (char*)malloc(strlen(curr->path) + 2);
                    sprintf(result, "%s%c", curr->path, direction);
                    return result;
                }
            }
            
            if (steps > 0 && !visited[nx][ny]) {
                State* newState = (State*)malloc(sizeof(State));
                newState->dist = curr->dist + steps;
                sprintf(newState->path, "%s%c", curr->path, direction);
                newState->x = nx;
                newState->y = ny;
                pq_push(&pq, newState);
            }
        }
    }
    
    char* result = (char*)malloc(11);
    strcpy(result, "impossible");
    return result;
}

int main() {
    printf("Dijkstra approach implemented\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn * log(mn))

Each cell can be visited at most once, and priority queue operations take O(log(mn))

⚡ Linearithmic

Space Complexity

O(mn)

Space for priority queue and distance tracking

⚡ Linearithmic Space

52.4K Views

Medium-High Frequency

~25 min Avg. Time

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

Dijkstra's Algorithm with Lexicographical Ordering — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler