Check if the Rectangle Corner Is Reachable

Check if the Rectangle Corner Is Reachable - Problem

Array Math Depth-First Search Breadth-First Search Union Find Geometry Hard

Imagine you're a robot trying to navigate from the bottom-left corner (0, 0) of a rectangular room to the top-right corner (xCorner, yCorner). However, there are circular obstacles scattered throughout the room that you must avoid!

Given:

Rectangle dimensions: xCorner and yCorner defining the top-right corner
Circular obstacles: An array circles[i] = [xi, yi, ri] where each circle has center (xi, yi) and radius ri

Your mission: Determine if there exists a path from (0, 0) to (xCorner, yCorner) such that:

The entire path stays inside the rectangle
The path doesn't touch or enter any circle
The path only touches the rectangle at the two corners

Return true if such a path exists, false otherwise. This is essentially asking: "Can you find a safe route through the obstacle course?"

Input & Output

example_1.py — Basic Case

$ Input: xCorner = 3, yCorner = 4, circles = [[2,1,1]]

› Output: true

💡 Note: There's a single circle at (2,1) with radius 1. We can find a path from (0,0) to (3,4) by going around the circle. For example, path along the left edge then top edge works.

example_2.py — Blocked Path

$ Input: xCorner = 3, yCorner = 3, circles = [[1,1,2]]

› Output: false

💡 Note: The circle at (1,1) with radius 2 is large enough to touch all four boundaries of the 3x3 rectangle, completely blocking any path from (0,0) to (3,3).

example_3.py — Multiple Circles

$ Input: xCorner = 3, yCorner = 4, circles = [[2,1,1],[1,2,1]]

› Output: false

💡 Note: Two overlapping circles create a barrier. The first circle (2,1,r=1) and second circle (1,2,r=1) together block all possible paths from bottom-left to top-right.

Visualization

Tap to expand

Understanding the Visualization

Setup the Scene

We have a rectangle with circular obstacles inside. The robot starts at (0,0) and wants to reach (xCorner, yCorner).

Model as Connectivity

Instead of finding a path, we check if obstacles create an impassable barrier. We create virtual boundary nodes.

Connect Components

Use Union-Find to group circles that touch each other and connect them to boundary nodes they touch.

Check Blocking

If left boundary connects to right boundary OR top connects to bottom, the path is blocked!

Key Takeaway

🎯 Key Insight: We don't need to find the actual path - just check if circles form a complete barrier connecting opposite boundaries of the rectangle!

Time & Space Complexity

Time Complexity

⏱️

O(n² × α(n))

Where n is number of circles, α is inverse Ackermann function (nearly constant)

⚠ Quadratic Growth

Space Complexity

O(n)

Space for Union-Find data structure

⚡ Linearithmic Space

Constraints

1 ≤ xCorner, yCorner ≤ 10⁹
1 ≤ circles.length ≤ 1000
circles[i].length == 3
1 ≤ x_i, y_i, r_i ≤ 10⁹

Asked in

G Google 28 f Meta 22 a Amazon 19 ⊞ Microsoft 15

The optimal solution uses Union-Find (Disjoint Set Union) to model this as a connectivity problem. Instead of finding the actual path, we check if circles form a blocking barrier by connecting circles to rectangle boundaries and checking if opposite boundaries become connected. Time complexity: O(n² × α(n)) where α is the inverse Ackermann function.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find (Disjoint Set Union)	O(n² × α(n))	O(n)	Check if circles form a blocking barrier using Union-Find data structure
Brute Force (Grid-based Path Search)	O(G² × C)	O(G²)	Discretize the rectangle into a grid and use BFS to find a path

Union-Find (Disjoint Set Union) — Algorithm Steps

Add 4 virtual nodes representing the rectangle boundaries
For each circle, check if it touches any boundary and union accordingly
For each pair of circles, check if they overlap and union if they do
Check if left boundary is connected to right boundary OR top to bottom
Return false if such connection exists, true otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create nodes for boundaries and circles

Boundary Connections

Connect circles touching rectangle edges

Circle Connections

Union overlapping circles

Check Blocking

Verify if opposite boundaries are connected

Code -

solution.c — C

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

typedef struct {
    int *parent;
    int *rank;
    int size;
} UnionFind;

UnionFind* createUF(int n) {
    UnionFind *uf = malloc(sizeof(UnionFind));
    uf->parent = malloc(n * sizeof(int));
    uf->rank = calloc(n, sizeof(int));
    uf->size = n;
    for (int i = 0; i < n; i++) uf->parent[i] = i;
    return uf;
}

int find(UnionFind *uf, int x) {
    if (uf->parent[x] != x) {
        uf->parent[x] = find(uf, uf->parent[x]);
    }
    return uf->parent[x];
}

void unite(UnionFind *uf, int x, int y) {
    int px = find(uf, x), py = find(uf, y);
    if (px == py) return;
    if (uf->rank[px] < uf->rank[py]) {
        int temp = px; px = py; py = temp;
    }
    uf->parent[py] = px;
    if (uf->rank[px] == uf->rank[py]) uf->rank[px]++;
}

bool canReachCorner(int xCorner, int yCorner, int** circles, int circlesSize, int* circlesColSize) {
    UnionFind *uf = createUF(circlesSize + 4);
    
    // Connect circles to boundaries
    for (int i = 0; i < circlesSize; i++) {
        int cx = circles[i][0], cy = circles[i][1], r = circles[i][2];
        if (cx - r <= 0) unite(uf, 0, i + 4);  // left
        if (cx + r >= xCorner) unite(uf, 1, i + 4);  // right
        if (cy + r >= yCorner) unite(uf, 2, i + 4);  // top
        if (cy - r <= 0) unite(uf, 3, i + 4);  // bottom
    }
    
    // Connect overlapping circles
    for (int i = 0; i < circlesSize; i++) {
        for (int j = i + 1; j < circlesSize; j++) {
            int cx1 = circles[i][0], cy1 = circles[i][1], r1 = circles[i][2];
            int cx2 = circles[j][0], cy2 = circles[j][1], r2 = circles[j][2];
            double dist = sqrt((cx1-cx2)*(cx1-cx2) + (cy1-cy2)*(cy1-cy2));
            if (dist <= r1 + r2) {
                unite(uf, i + 4, j + 4);
            }
        }
    }
    
    // Check if path is blocked
    bool result = !(find(uf, 0) == find(uf, 1) || find(uf, 2) == find(uf, 3));
    
    free(uf->parent);
    free(uf->rank);
    free(uf);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × α(n))

Where n is number of circles, α is inverse Ackermann function (nearly constant)

⚠ Quadratic Growth

Space Complexity

O(n)

Space for Union-Find data structure

⚡ Linearithmic Space

Constraints

1 ≤ xCorner, yCorner ≤ 10⁹
1 ≤ circles.length ≤ 1000
circles[i].length == 3
1 ≤ x_i, y_i, r_i ≤ 10⁹

26.1K Views

Medium Frequency

~35 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

Union-Find (Disjoint Set Union) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler