Reaching Points - Practice Coding Problems

Reaching Points - Problem

Math Hard

You're given a starting point (sx, sy) and a target point (tx, ty) on a 2D coordinate plane. Your goal is to determine if you can transform the starting point into the target point using a specific set of operations.

The allowed operations are:

From point (x, y), you can move to (x + y, y) - add y-coordinate to x-coordinate
From point (x, y), you can move to (x, x + y) - add x-coordinate to y-coordinate

Example: Starting from (1, 1), you could reach (3, 2) by: (1, 1) → (1, 2) → (3, 2)

Return true if it's possible to reach the target point, false otherwise.

Input & Output

example_1.py — Basic Case

$ Input: [1, 1, 3, 5]

› Output: true

💡 Note: We can reach (3,5) from (1,1): (1,1) → (1,2) → (3,2) → (3,5). Each step uses one of the allowed operations.

example_2.py — Impossible Case

$ Input: [1, 1, 2, 2]

› Output: false

💡 Note: From (1,1), we can reach (1,2), (2,1), (2,3), (3,2), etc., but never (2,2). The operations always increase one coordinate significantly.

example_3.py — Same Point

$ Input: [1, 1, 1, 1]

› Output: true

💡 Note: The starting point is already the target point, so no operations are needed.

Visualization

Tap to expand

Understanding the Visualization

Forward Explosion

Going forward creates exponentially many paths - like exploring every possible climbing route

Reverse Insight

Working backwards, there's only one way to reach each rung - much more efficient!

Modular Magic

When coordinates differ greatly, use modular arithmetic to skip many identical steps

Convergence

Keep working backwards until you reach the start or prove it's impossible

Key Takeaway

🎯 Key Insight: Working backwards with modular arithmetic transforms an exponential problem into a logarithmic one, making it efficient even for coordinates up to 10^9.

Time & Space Complexity

Time Complexity

⏱️

O(2^(tx+ty))

Each step can branch into 2 possibilities, leading to exponential growth

✓ Linear Growth

Space Complexity

O(2^(tx+ty))

Recursion stack and memoization table can grow exponentially

✓ Linear Space

Constraints

1 ≤ sx, sy, tx, ty ≤ 10⁹
Coordinates are positive integers
Operations only increase coordinate values
Must handle large coordinate differences efficiently

Asked in

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

The optimal approach works backwards from the target point using modular arithmetic to efficiently skip multiple steps. Instead of exploring exponentially many forward paths, we reverse the operations and use the mathematical insight that tx % ty can eliminate many steps at once. This reduces time complexity from O(2^n) to O(log n), making it feasible for large coordinates up to 10^9.

Common Approaches

Approach	Time	Space	Notes
✓ Forward BFS/DFS (Brute Force)	O(2^(tx+ty))	O(2^(tx+ty))	Explore all possible forward paths from start to target
Reverse with Optimization (Optimal)	O(log(max(tx, ty)))	O(1)	Work backwards from target using modular arithmetic to optimize large steps

Forward BFS/DFS (Brute Force) — Algorithm Steps

Start with the source point (sx, sy)
For each point, try both operations: (x, x+y) and (x+y, y)
If we reach (tx, ty), return true
If either coordinate exceeds the target, backtrack (impossible to reach)
Use memoization to avoid revisiting the same points

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Point

Begin at source (sx, sy)

Branch Out

Try both operations: (x+y, y) and (x, x+y)

Recursive Exploration

Continue branching until target found or coordinates exceed target

Code -

solution.c — C

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

bool dfs(long long x, long long y, long long tx, long long ty) {
    if (x > tx || y > ty) {
        return false;
    }
    if (x == tx && y == ty) {
        return true;
    }
    
    return dfs(x + y, y, tx, ty) || dfs(x, x + y, tx, ty);
}

bool reachingPoints(int sx, int sy, int tx, int ty) {
    return dfs(sx, sy, tx, ty);
}

int main() {
    int sx, sy, tx, ty;
    scanf("[%d, %d, %d, %d]", &sx, &sy, &tx, &ty);
    printf("%s\n", reachingPoints(sx, sy, tx, ty) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(tx+ty))

Each step can branch into 2 possibilities, leading to exponential growth

✓ Linear Growth

Space Complexity

O(2^(tx+ty))

Recursion stack and memoization table can grow exponentially

✓ Linear Space

Constraints

1 ≤ sx, sy, tx, ty ≤ 10⁹
Coordinates are positive integers
Operations only increase coordinate values
Must handle large coordinate differences efficiently

27.4K Views

Medium Frequency

~25 min Avg. Time

896 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

Forward BFS/DFS (Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler