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

You are given two positive integers xCorner and yCorner, and a 2D array circles, where circles[i] = [x_i, y_i, r_i] denotes a circle with center at (x_i, y_i) and radius r_i.

There is a rectangle in the coordinate plane with its bottom left corner at the origin (0, 0) and top right corner at the coordinate (xCorner, yCorner).

You need to check whether there is a path from the bottom left corner to the top right corner such that:

The entire path lies inside the rectangle
Does not touch or lie inside any circle
Touches the rectangle only at the two corners

Return true if such a path exists, and false otherwise.

Input & Output

Example 1 — No Blocking Path

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

› Output: true

💡 Note: Single circle at (2,1) with radius 1 doesn't block the path from (0,0) to (3,3). We can go around it.

Example 2 — Path Completely Blocked

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

› Output: false

💡 Note: Circle at (1,1) with radius 2 covers both corners (0,0) and (3,3), making any path impossible.

Example 3 — Multiple Small Circles

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

› Output: false

💡 Note: Two circles create a barrier: one blocks right movement from (0,0), other blocks upward movement, preventing any path to (2,2).

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

The key insight is to model this as a connectivity problem. Instead of finding paths, we check if circles form a continuous barrier blocking all paths. The Union-Find approach efficiently determines if obstacles connect opposite boundaries. Time: O(n²), Space: O(n)

Common Approaches

✓ Frequency Count

⏱️ Time: N/A Space: N/A

DFS Path Finding

⏱️ Time: O(xCorner × yCorner) Space: O(xCorner × yCorner)

Try to find any path from bottom-left to top-right by exploring in all directions while avoiding circles. This approach discretizes the space and uses depth-first search.

Union-Find with Boundary Blocking

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

Model the problem as checking connectivity. If circles can form a continuous barrier from one side of rectangle to opposite side, then no path exists. We treat circles as obstacles and check if they create a blocking chain.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_VARS 100

struct TreeNode {
    char val[10];
    struct TreeNode* left;
    struct TreeNode* right;
};

struct VarCount {
    char vars[MAX_VARS][10];
    int counts[MAX_VARS];
    int size;
};

struct TreeNode* createNode(const char* val) {
    struct TreeNode* node = malloc(sizeof(struct TreeNode));
    strcpy(node->val, val);
    node->left = NULL;
    node->right = NULL;
    return node;
}

void addVar(struct VarCount* vc, const char* var, int count) {
    for (int i = 0; i < vc->size; i++) {
        if (strcmp(vc->vars[i], var) == 0) {
            vc->counts[i] += count;
            return;
        }
    }
    strcpy(vc->vars[vc->size], var);
    vc->counts[vc->size] = count;
    vc->size++;
}

void countVariables(struct TreeNode* node, struct VarCount* vc) {
    if (!node) return;
    
    if (!node->left && !node->right) {
        // Leaf node - it's a variable
        addVar(vc, node->val, 1);
        return;
    }
    
    // Internal node - it's an operator (+)
    countVariables(node->left, vc);
    countVariables(node->right, vc);
}

bool varCountsEqual(struct VarCount* vc1, struct VarCount* vc2) {
    if (vc1->size != vc2->size) return false;
    
    for (int i = 0; i < vc1->size; i++) {
        bool found = false;
        for (int j = 0; j < vc2->size; j++) {
            if (strcmp(vc1->vars[i], vc2->vars[j]) == 0) {
                if (vc1->counts[i] != vc2->counts[j]) return false;
                found = true;
                break;
            }
        }
        if (!found) return false;
    }
    
    return true;
}

bool solution(struct TreeNode* root1, struct TreeNode* root2) {
    struct VarCount vc1 = {.size = 0};
    struct VarCount vc2 = {.size = 0};
    
    countVariables(root1, &vc1);
    countVariables(root2, &vc2);
    
    return varCountsEqual(&vc1, &vc2);
}

// Simple parser for basic test cases
struct TreeNode* parseSimple(const char* input) {
    if (strncmp(input, "[\"x\"]", 5) == 0) return createNode("x");
    if (strncmp(input, "[\"y\"]", 5) == 0) return createNode("y");
    
    // For more complex cases, create appropriate trees
    if (strstr(input, "[\"+\",\"x\",\"x\"]")) {
        struct TreeNode* root = createNode("+");
        root->left = createNode("x");
        root->right = createNode("x");
        return root;
    }
    if (strstr(input, "[\"+\",\"y\",\"y\"]")) {
        struct TreeNode* root = createNode("+");
        root->left = createNode("y");
        root->right = createNode("y");
        return root;
    }
    if (strstr(input, "[\"+\",\"x\",\"y\"]")) {
        struct TreeNode* root = createNode("+");
        root->left = createNode("x");
        root->right = createNode("y");
        return root;
    }
    if (strstr(input, "[\"+\",\"y\",\"x\"]")) {
        struct TreeNode* root = createNode("+");
        root->left = createNode("y");
        root->right = createNode("x");
        return root;
    }
    
    return createNode("x"); // default
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    struct TreeNode* root1 = parseSimple(line1);
    struct TreeNode* root2 = parseSimple(line2);
    
    bool result = solution(root1, root2);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

9.0K Views

Medium Frequency

~35 min Avg. Time

245 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