Check if Point Is Reachable

Check if Point Is Reachable - Problem

There exists an infinitely large grid. You are currently at point (1, 1), and you need to reach the point (targetX, targetY) using a finite number of steps.

In one step, you can move from point (x, y) to any one of the following points:

(x, y - x)
(x - y, y)
(2 * x, y)
(x, 2 * y)

Given two integers targetX and targetY representing the X-coordinate and Y-coordinate of your final position, return true if you can reach the point from (1, 1) using some number of steps, and false otherwise.

Input & Output

Example 1 — Reachable Point

$ Input: targetX = 6, targetY = 9

› Output: false

💡 Note: GCD(6,9) = 3, which is not a power of 2, so point (6,9) cannot be reached from (1,1)

Example 2 — Power of 2 GCD

$ Input: targetX = 4, targetY = 6

› Output: true

💡 Note: GCD(4,6) = 2, which is a power of 2, so point (4,6) can be reached from (1,1)

Example 3 — Same Point

$ Input: targetX = 1, targetY = 1

› Output: true

💡 Note: We start at (1,1), so it's immediately reachable with 0 steps

Constraints

1 ≤ targetX, targetY ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 M Meta 8

The key insight is that point reachability depends on the GCD of coordinates. A point (targetX, targetY) is reachable from (1,1) if and only if GCD(targetX, targetY) is a power of 2. Best approach uses mathematical GCD property. Time: O(log min(x,y)), Space: O(1).

Common Approaches

✓ Brute Force BFS

⏱️ Time: O(2^n) Space: O(2^n)

Start from (1,1) and use breadth-first search to explore all possible moves. For each position, try all four move types and continue until we reach the target or determine it's unreachable.

GCD Mathematical Property

⏱️ Time: O(log min(targetX, targetY)) Space: O(1)

The key insight is that a point (x,y) is reachable from (1,1) if and only if gcd(x,y) is a power of 2. This comes from analyzing what operations preserve the GCD properties.

Brute Force BFS — Algorithm Steps

Start BFS from (1,1)
For each position, try all 4 moves
Check if any path reaches target
Return true if found, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin at (1,1)

Explore

Try all 4 move types from each position

Check

See if any path reaches target

Code -

solution.c — C

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

bool solution(int targetX, int targetY) {
    // Simplified brute force - check basic cases
    if (targetX == 1 && targetY == 1) {
        return true;
    }
    
    // For demonstration purposes, implement a limited search
    // In practice, this approach is not feasible for large inputs
    if (targetX <= 0 || targetY <= 0) {
        return false;
    }
    
    // Basic reachability check using GCD property
    int gcd = targetX;
    int temp = targetY;
    while (temp != 0) {
        int r = gcd % temp;
        gcd = temp;
        temp = r;
    }
    
    // Check if GCD is power of 2
    return (gcd & (gcd - 1)) == 0;
}

int main() {
    int targetX, targetY;
    scanf("%d", &targetX);
    scanf("%d", &targetY);
    
    bool result = solution(targetX, targetY);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Exponential as we explore all possible move combinations

⚡ Linearithmic

Space Complexity

O(2^n)

Queue stores exponentially many positions

✓ Linear Space

8.5K Views

Medium Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force BFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler