Determine if a Cell Is Reachable at a Given Time

Determine if a Cell Is Reachable at a Given Time - Problem

Math Medium

You're navigating through an infinite 2D grid where you can move like a king in chess - in any of the 8 directions (horizontally, vertically, or diagonally) to adjacent cells.

Given your starting position (sx, sy) and target position (fx, fy), determine if you can reach the target in exactly t seconds.

Here's the catch: You must move every second - no standing still! However, you can revisit cells multiple times, allowing you to "waste" time by moving back and forth.

Goal: Return true if you can reach (fx, fy) after exactly t seconds, false otherwise.

Input & Output

example_1.py — Basic Movement

$ Input: sx = 2, sy = 4, fx = 7, fy = 7, t = 6

› Output: true

💡 Note: Min distance = max(|7-2|, |7-4|) = max(5,3) = 5. Since t=6 ≥ 5 and (6-5)=1 is odd, but we can reach in 5 and waste 1 step by going back and forth... Wait, that's wrong. Actually (6-5)%2=1≠0, so answer should be false. Let me recalculate: we need exactly 6 steps, min is 5, extra is 1 (odd), so false.

example_2.py — Same Position Edge Case

$ Input: sx = 1, sy = 1, fx = 1, fy = 1, t = 1

› Output: false

💡 Note: Already at target but must move exactly 1 step. Cannot return to same position in 1 move (need 2 moves minimum for round trip).

example_3.py — Perfect Timing

$ Input: sx = 1, sy = 1, fx = 3, fy = 3, t = 3

› Output: false

💡 Note: Min distance = max(|3-1|, |3-1|) = max(2,2) = 2. We have t=3, so extra time = 3-2 = 1 (odd). Cannot waste exactly 1 step and return to target.

Visualization

Tap to expand

Understanding the Visualization

Calculate Minimum Path

King moves diagonally when possible - distance is max(dx, dy)

Reach Target Optimally

Take shortest diagonal path to destination

Waste Extra Time

Move back and forth between adjacent cells

Return to Target

End exactly at target after wasting even number of moves

Key Takeaway

🎯 Key Insight: The elegant mathematical solution recognizes that diagonal movement minimizes distance, and any extra time must be even to allow back-and-forth movement while ending at the target.

Time & Space Complexity

Time Complexity

⏱️

O(8^t)

8 possible moves at each of t time steps creates exponential explosion

✓ Linear Growth

Space Complexity

O(t)

Recursion depth limited by time t, but exponential paths explored

✓ Linear Space

Constraints

1 ≤ sx, sy, fx, fy ≤ 10⁹
0 ≤ t ≤ 10⁹
Grid is infinite - no boundary constraints
Must move every second - no staying in place

Asked in

G Google 24 ⊞ Microsoft 18 f Meta 15 a Amazon 12

The optimal solution uses mathematical analysis to solve this in O(1) time. Key insight: calculate the Chebyshev distance (diagonal movement) as max(|dx|, |dy|), ensure we have enough time, and verify extra time is even for back-and-forth movement. Special case: cannot waste exactly 1 second when already at target.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recursive Exploration)	O(8^t)	O(t)	Try all possible 8^t movement sequences to see if any reaches the target
Mathematical Analysis (Optimal)	O(1)	O(1)	Calculate minimum distance needed and check if remaining time allows return trips

Brute Force (Recursive Exploration) — Algorithm Steps

Start from (sx, sy) with t seconds remaining
For each of 8 possible moves, recursively explore
Base case: if time = 0, check if at target position
Return true if any path leads to success

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Begin at (sx, sy) with t seconds

Branch Out

Explore all 8 possible moves

Recursive Expansion

Each path branches into 8 more paths

Exponential Growth

Tree grows to 8^t total paths

Code -

solution.c — C

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

int directions[8][2] = {{-1,-1},{-1,0},{-1,1},{0,-1},{0,1},{1,-1},{1,0},{1,1}};

bool dfs(int x, int y, int fx, int fy, int timeLeft) {
    if (timeLeft == 0) {
        return x == fx && y == fy;
    }
    
    for (int i = 0; i < 8; i++) {
        int newX = x + directions[i][0];
        int newY = y + directions[i][1];
        if (dfs(newX, newY, fx, fy, timeLeft - 1)) {
            return true;
        }
    }
    return false;
}

bool canReachAtTime(int sx, int sy, int fx, int fy, int t) {
    return dfs(sx, sy, fx, fy, t);
}

int main() {
    int sx, sy, fx, fy, t;
    scanf("%d %d %d %d %d", &sx, &sy, &fx, &fy, &t);
    printf("%s\n", canReachAtTime(sx, sy, fx, fy, t) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(8^t)

8 possible moves at each of t time steps creates exponential explosion

✓ Linear Growth

Space Complexity

O(t)

Recursion depth limited by time t, but exponential paths explored

✓ Linear Space

Constraints

1 ≤ sx, sy, fx, fy ≤ 10⁹
0 ≤ t ≤ 10⁹
Grid is infinite - no boundary constraints
Must move every second - no staying in place

28.6K Views

Medium Frequency

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

Brute Force (Recursive Exploration) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler