Escape a Large Maze

Escape a Large Maze - Problem

There is a 1 million by 1 million grid on an XY-plane, and the coordinates of each grid square are (x, y).

We start at the source = [sx, sy] square and want to reach the target = [tx, ty] square. There is also an array of blocked squares, where each blocked[i] = [xi, yi] represents a blocked square with coordinates (xi, yi).

Each move, we can walk one square north, east, south, or west if the square is not in the array of blocked squares. We are also not allowed to walk outside of the grid.

Return true if and only if it is possible to reach the target square from the source square through a sequence of valid moves.

Input & Output

Example 1 — No Blocked Cells

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

› Output: true

💡 Note: With no blocked cells, we can always reach any cell from any other cell in the grid.

Example 2 — Source is Enclosed

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

› Output: false

💡 Note: The source [0,0] is blocked by cells [0,1] and [1,0], forming a corner trap that prevents reaching [0,2].

Example 3 — Path Exists Around Blocks

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

› Output: true

💡 Note: Even with [0,1] blocked, we can go from [0,0] → [1,0] → [1,1] → [1,2] → [0,2] to reach the target.

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
It is guaranteed that source and target are not blocked.

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 8

The key insight is that with at most 200 blocked cells, any enclosed area has maximum size 200×199/2 = 19,900 cells. The optimal approach uses bidirectional BFS with area limits - if we explore more than this limit from either source or target, we know that point isn't trapped. Time: O(B²), Space: O(B²) where B is the number of blocked cells.

Common Approaches

✓ Brute Force BFS

⏱️ Time: O(10¹²) Space: O(10¹²)

Use breadth-first search to explore all reachable cells from source. If we reach target, return true. This approach works but is inefficient for large grids.

Optimized BFS with Area Limit

⏱️ Time: O(B²) Space: O(B²)

Key insight: with B blocked cells, maximum enclosed area is B*(B-1)/2. If we explore more cells than this limit, we know we're not trapped in an enclosure.

Brute Force BFS — Algorithm Steps

Convert blocked array to set for O(1) lookup
Start BFS from source
Explore all 4 directions from each cell
Return true if target is reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start BFS from source, mark blocked cells

Explore

Visit all adjacent unblocked cells level by level

Result

Return true if target is reached, false otherwise

Code -

solution.c — C

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

#define MAX_BLOCKED 200
#define MAX_VISITED 20000
#define GRID_SIZE 1000000

typedef struct {
    int x, y;
} Point;

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

Queue* createQueue(int capacity) {
    Queue* q = malloc(sizeof(Queue));
    q->data = malloc(capacity * sizeof(Point));
    q->front = q->rear = q->size = 0;
    q->capacity = capacity;
    return q;
}

void enqueue(Queue* q, Point p) {
    q->data[q->rear] = p;
    q->rear = (q->rear + 1) % q->capacity;
    q->size++;
}

Point dequeue(Queue* q) {
    Point p = q->data[q->front];
    q->front = (q->front + 1) % q->capacity;
    q->size--;
    return p;
}

bool isEmpty(Queue* q) {
    return q->size == 0;
}

void freeQueue(Queue* q) {
    free(q->data);
    free(q);
}

bool isBlocked(Point p, Point* blocked, int blocked_count) {
    for (int i = 0; i < blocked_count; i++) {
        if (blocked[i].x == p.x && blocked[i].y == p.y) {
            return true;
        }
    }
    return false;
}

bool isVisited(Point p, Point* visited, int visited_count) {
    for (int i = 0; i < visited_count; i++) {
        if (visited[i].x == p.x && visited[i].y == p.y) {
            return true;
        }
    }
    return false;
}

bool bfs(Point start, Point end, Point* blocked, int blocked_count, int max_area) {
    if (isBlocked(start, blocked, blocked_count)) {
        return false;
    }
    
    Queue* q = createQueue(MAX_VISITED);
    Point visited[MAX_VISITED];
    int visited_count = 0;
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
    enqueue(q, start);
    visited[visited_count++] = start;
    
    while (!isEmpty(q) && visited_count <= max_area) {
        Point current = dequeue(q);
        
        if (current.x == end.x && current.y == end.y) {
            freeQueue(q);
            return true;
        }
        
        for (int i = 0; i < 4; i++) {
            Point next = {current.x + directions[i][0], current.y + directions[i][1]};
            
            if (next.x >= 0 && next.x < GRID_SIZE && next.y >= 0 && next.y < GRID_SIZE) {
                if (!isBlocked(next, blocked, blocked_count) && !isVisited(next, visited, visited_count)) {
                    visited[visited_count++] = next;
                    enqueue(q, next);
                }
            }
        }
    }
    
    bool result = visited_count > max_area;
    freeQueue(q);
    return result;
}

bool solution(Point* blocked, int blocked_count, Point source, Point target) {
    if (blocked_count == 0) {
        return true;
    }
    
    int max_area = blocked_count * (blocked_count - 1) / 2;
    
    return bfs(source, target, blocked, blocked_count, max_area) && 
           bfs(target, source, blocked, blocked_count, max_area);
}

int parseArray(char* s, Point* blocked) {
    int count = 0;
    if (strcmp(s, "[]") == 0) {
        return 0;
    }
    
    char* token = strtok(s, "[,]");
    while (token != NULL && count < MAX_BLOCKED) {
        if (strlen(token) > 0 && token[0] >= '0' && token[0] <= '9') {
            blocked[count].x = atoi(token);
            token = strtok(NULL, "[,]");
            if (token != NULL) {
                blocked[count].y = atoi(token);
                count++;
            }
        }
        token = strtok(NULL, "[,]");
    }
    
    return count;
}

Point parsePoint(char* s) {
    Point p = {0, 0};
    char* token = strtok(s, "[,]");
    if (token != NULL) {
        p.x = atoi(token);
        token = strtok(NULL, "[,]");
        if (token != NULL) {
            p.y = atoi(token);
        }
    }
    return p;
}

int main() {
    char line1[1000], line2[100], line3[100];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    fgets(line3, sizeof(line3), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    line3[strcspn(line3, "\n")] = 0;
    
    Point blocked[MAX_BLOCKED];
    int blocked_count = parseArray(line1, blocked);
    
    Point source = parsePoint(line2);
    Point target = parsePoint(line3);
    
    bool result = solution(blocked, blocked_count, source, target);
    printf("%s\n", result ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(10¹²)

In worst case, might explore the entire 10⁶ × 10⁶ grid

✓ Linear Growth

Space Complexity

O(10¹²)

BFS queue and visited set could contain millions of cells

✓ Linear Space

18.5K Views

Medium Frequency

~35 min Avg. Time

432 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 BFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler