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

Math Medium

You are given four integers sx, sy, fx, fy, and a non-negative integer t.

In an infinite 2D grid, you start at the cell (sx, sy). Each second, you must move to any of its adjacent cells.

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

A cell's adjacent cells are the 8 cells around it that share at least one corner with it. You can visit the same cell several times.

Input & Output

Example 1 — Cannot Reach in Time

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

› Output: false

💡 Note: Minimum distance is max(|4-2|, |3-1|) = max(2,2) = 2. We need exactly 3 seconds, but after reaching in 2 seconds, we have 1 second left (odd). We can't waste exactly 1 second with back-and-forth movement.

Example 2 — Perfect Timing

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

› Output: true

💡 Note: Start and target are the same. Since t=3 is odd and we need to move each second, we can move to an adjacent cell and return (takes 2 seconds), then move away and back again (1 more second).

Example 3 — Insufficient Time

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

› Output: false

💡 Note: Minimum distance is max(|5-1|, |5-1|) = max(4,4) = 4 seconds. We only have 3 seconds available, so it's impossible to reach the target.

Constraints

1 ≤ sx, sy, fx, fy ≤ 10⁹
0 ≤ t ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 28 M Microsoft 22 🍎 Apple 15 M Meta 12

The key insight is using Chebyshev distance - the minimum time to reach target (fx,fy) from (sx,sy) is max(|fx-sx|, |fy-sy|) because we can move diagonally. The remaining time must be even to allow back-and-forth movement. Best approach is the mathematical solution with Time: O(1), Space: O(1).

Common Approaches

✓ Brute Force - Try All Paths

⏱️ Time: O(8^t) Space: O(t)

Recursively explore all 8 possible moves at each second until t seconds are used. Check if any path reaches the target position exactly at time t.

Mathematical Solution - Chebyshev Distance

⏱️ Time: O(1) Space: O(1)

Use Chebyshev distance (max of horizontal and vertical distances) to find minimum time needed. Then check if remaining time allows for valid back-and-forth movement.

Optimized BFS (Level-wise)

⏱️ Time: O(8^t) Space: O(8^t)

Perform breadth-first search level by level, where each level represents one second. Track visited positions at each time to avoid redundant exploration.

Brute Force - Try All Paths — Algorithm Steps

Start recursion from (sx, sy) with t seconds remaining
At each step, try all 8 adjacent moves
If time is 0, check if we're at target
Return true if any path succeeds

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin at (sx, sy) with t seconds

Explore

Try all 8 adjacent moves recursively

Check

At time 0, verify if we reached target

Code -

solution.c — C

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

bool dfs(int x, int y, int fx, int fy, int timeLeft) {
    if (timeLeft == 0) {
        return x == fx && y == fy;
    }
    
    // Try all 8 adjacent cells
    for (int dx = -1; dx <= 1; dx++) {
        for (int dy = -1; dy <= 1; dy++) {
            if (dx == 0 && dy == 0) continue;
            if (dfs(x + dx, y + dy, fx, fy, timeLeft - 1)) {
                return true;
            }
        }
    }
    return false;
}

bool solution(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", &sx);
    scanf("%d", &sy);
    scanf("%d", &fx);
    scanf("%d", &fy);
    scanf("%d", &t);
    bool result = solution(sx, sy, fx, fy, t);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(8^t)

Each second we have 8 choices, leading to 8^t total paths

✓ Linear Growth

Space Complexity

O(t)

Recursion stack depth is at most t levels

✓ Linear Space

23.5K Views

Medium Frequency

~15 min Avg. Time

847 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

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Paths — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler