Escape a Large Maze - Practice Coding Problems

Escape a Large Maze - Problem

Imagine you're trapped in a massive 1 million × 1 million grid and need to escape! You start at a source position [sx, sy] and must reach a target position [tx, ty].

However, there's a catch: certain squares are blocked and you cannot pass through them. You can only move in four directions: north, south, east, or west - one square at a time.

The Challenge: Given an array of blocked coordinates, determine if it's possible to reach the target from the source. The twist? The grid is so large that a naive BFS/DFS would timeout, so you need a clever insight!

Key Insight: With at most 200 blocked squares, the maximum area that can be enclosed is limited. If we can explore more than this maximum area from either source or target, we know we're not trapped!

Input & Output

example_1.py — Basic escape possible

$ Input: blocked = [[0,1],[1,0]], source = [0,0], target = [0,2]

› Output: false

💡 Note: The source is blocked from reaching the target by the blocked squares. From [0,0] we can only move to unblocked adjacent squares, but the blocked squares at [0,1] and [1,0] prevent any path to [0,2].

example_2.py — Empty blocked array

$ Input: blocked = [], source = [0,0], target = [999999,999999]

› Output: true

💡 Note: With no blocked squares, we can always find a path from source to target in the grid. The path exists even though it might be very long.

example_3.py — Large enclosed area

$ Input: blocked = [[0,0],[0,1],[0,2],[1,0],[2,0]], source = [1,1], target = [999999,999999]

› Output: false

💡 Note: The source [1,1] is completely enclosed by the blocked squares forming a barrier. No matter which direction we move from [1,1], we hit a blocked square or the boundary formed by blocked squares.

Visualization

Tap to expand

Understanding the Visualization

Optimal Barrier Placement

The worst case is when blocked cells form a triangle against the grid boundary

Calculate Max Area

A triangle with B blocked cells can enclose at most B*(B-1)/2 area

Early Escape Detection

If BFS explores more than this area, we've proven escape is possible

Bidirectional Check

Test both source and target to ensure neither is trapped

Key Takeaway

🎯 Key Insight: The maximum area that N blocked cells can enclose is N×(N-1)/2. If BFS explores more cells than this from either source or target, that point cannot be trapped!

Time & Space Complexity

Time Complexity

⏱️

O(B²)

Where B is the number of blocked cells (at most 200). We explore at most B² cells from each of source and target

✓ Linear Growth

Space Complexity

O(B²)

Visited set stores at most B² coordinates for each BFS

✓ Linear Space

Constraints

0 ≤ blocked.length ≤ 200
blocked[i].length == 2
0 ≤ x_i, y_i < 10⁶
source.length == target.length == 2
0 ≤ s_x, s_y, t_x, t_y < 10⁶
source ≠ target
All blocked squares are unique

Asked in

G Google 45 f Facebook 32 a Amazon 28 ⊞ Microsoft 22

The optimal solution uses bounded BFS with early termination. Key insight: with at most 200 blocked cells, the maximum enclosed area is ~200²/2. If we explore more cells than this limit from either source or target, we prove that point is not trapped. Run BFS from both ends with this termination condition - only return false if both are proven trapped.

Common Approaches

Approach	Time	Space	Notes
✓ Naive BFS/DFS (Time Limit Exceeded)	O(10^12)	O(10^12)	Standard BFS to explore all reachable cells until target is found
Bounded BFS with Early Termination (Optimal)	O(B²)	O(B²)	Use BFS but terminate early if we explore enough cells to prove we're not trapped

Naive BFS/DFS (Time Limit Exceeded) — Algorithm Steps

Convert blocked array to a set for O(1) lookup
Initialize BFS queue with source position
For each cell, explore all 4 directions
Mark visited cells to avoid cycles
Return true if target is reached, false if queue is empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Start BFS

Begin from source, add to queue

Explore neighbors

Check all 4 directions from current position

Continue until target

Keep exploring until target found or no more cells

Code -

solution.c — C

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

typedef struct {
    int x, y;
} Point;

typedef struct {
    Point* data;
    int front, rear, size, capacity;
} Queue;

bool isEscapePossible(int** blocked, int blockedSize, int* blockedColSize, int* source, int sourceSize, int* target, int targetSize) {
    // This is a simplified version - full implementation would need hash table for blocked cells
    // and proper queue management
    
    Queue* queue = (Queue*)malloc(sizeof(Queue));
    queue->capacity = 1000000;
    queue->data = (Point*)malloc(queue->capacity * sizeof(Point));
    queue->front = 0;
    queue->rear = 0;
    queue->size = 0;
    
    // Add source to queue
    queue->data[queue->rear] = (Point){source[0], source[1]};
    queue->rear = (queue->rear + 1) % queue->capacity;
    queue->size++;
    
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
    while (queue->size > 0) {
        Point curr = queue->data[queue->front];
        queue->front = (queue->front + 1) % queue->capacity;
        queue->size--;
        
        if (curr.x == target[0] && curr.y == target[1]) {
            free(queue->data);
            free(queue);
            return true;
        }
        
        for (int i = 0; i < 4; i++) {
            int nx = curr.x + directions[i][0];
            int ny = curr.y + directions[i][1];
            
            if (nx >= 0 && nx < 1000000 && ny >= 0 && ny < 1000000) {
                // Check if blocked and not visited (simplified)
                queue->data[queue->rear] = (Point){nx, ny};
                queue->rear = (queue->rear + 1) % queue->capacity;
                queue->size++;
            }
        }
    }
    
    free(queue->data);
    free(queue);
    return false;
}

Time & Space Complexity

Time Complexity

⏱️

O(10^12)

In worst case, might need to explore the entire 10^6 × 10^6 grid

✓ Linear Growth

Space Complexity

O(10^12)

Visited set could store up to 10^12 coordinates

✓ Linear Space

Constraints

0 ≤ blocked.length ≤ 200
blocked[i].length == 2
0 ≤ x_i, y_i < 10⁶
source.length == target.length == 2
0 ≤ s_x, s_y, t_x, t_y < 10⁶
source ≠ target
All blocked squares are unique

26.4K Views

Medium-High Frequency

~25 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Naive BFS/DFS (Time Limit Exceeded) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler