Find Nearest Point That Has the Same X or Y Coordinate

Find Nearest Point That Has the Same X or Y Coordinate - Problem

Array Easy

Imagine you're standing at a specific location (x, y) on a grid, and there are several points scattered around you. You can only move to points that are either directly horizontal (same x-coordinate) or directly vertical (same y-coordinate) from your current position - like a rook in chess!

Your task is to find the closest valid point using Manhattan distance (the sum of horizontal and vertical distances). If multiple points are equally close, choose the one with the smallest index.

Input: Your current coordinates (x, y) and an array points where each points[i] = [ai, bi] represents a point at (ai, bi).

Output: The index of the nearest valid point, or -1 if no valid points exist.

Manhattan Distance Formula: |x1 - x2| + |y1 - y2|

Input & Output

example_1.py — Basic Case

$ Input: x = 3, y = 4, points = [[1,2],[3,1],[2,4],[2,3],[4,4]]

› Output: 2

💡 Note: Point at index 2 [2,4] shares y-coordinate 4 with distance |3-2| + |4-4| = 1, which is the minimum among all valid points.

example_2.py — No Valid Points

$ Input: x = 3, y = 4, points = [[3,4]]

› Output: 0

💡 Note: The only point [3,4] is at the exact same location, so distance is 0. This is valid since it shares both coordinates.

example_3.py — No Valid Points

$ Input: x = 3, y = 4, points = [[2,3]]

› Output: -1

💡 Note: Point [2,3] doesn't share x-coordinate (2≠3) or y-coordinate (3≠4), so no valid points exist.

Visualization

Tap to expand

Understanding the Visualization

Identify Your Position

You are at coordinates (x, y) on the grid

Scan All Points

Check each point to see if it shares your x or y coordinate

Calculate Distance

For valid points, compute Manhattan distance: |x1-x2| + |y1-y2|

Track the Best

Keep the closest point (or earliest index if tied)

Return Result

Output the index of the best valid point found

Key Takeaway

🎯 Key Insight: This is fundamentally a filtering and comparison problem - we must check every point for validity anyway, making a simple linear scan the optimal O(n) solution!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Must examine each point once to check validity and calculate distance

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track the best result

✓ Linear Space

Constraints

1 ≤ points.length ≤ 10⁴
points[i].length == 2
1 ≤ x, y, ai, bi ≤ 10⁴
All coordinates are positive integers

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 15

The optimal solution uses a single linear scan through all points. For each point, we check if it's valid (shares x or y coordinate), calculate the Manhattan distance if valid, and keep track of the closest point with the smallest index. Time complexity is O(n) which is optimal since we must examine every point.

Common Approaches

Approach	Time	Space	Notes
✓ Linear Scan (Optimal Solution)	O(n)	O(1)	Check each point, validate it, calculate distance, and track the best option

Linear Scan (Optimal Solution) — Algorithm Steps

Initialize variables to track the best index and minimum distance
Iterate through each point with its index
Check if the point is valid (same x or y coordinate)
If valid, calculate Manhattan distance
Update best result if this point is closer (or same distance but smaller index)
Return the best index found, or -1 if no valid points exist

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set minDistance = ∞, bestIndex = -1

Check Point 0

Validate coordinates and calculate distance

Check Point 1

Compare with current best

Continue Scanning

Process remaining points

Return Result

Return the index of closest valid point

Code -

solution.c — C

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

int nearestValidPoint(int x, int y, int** points, int pointsSize) {
    int minDistance = INT_MAX;
    int bestIndex = -1;
    
    for (int i = 0; i < pointsSize; i++) {
        int px = points[i][0], py = points[i][1];
        // Check if point is valid (shares x or y coordinate)
        if (px == x || py == y) {
            // Calculate Manhattan distance
            int distance = abs(x - px) + abs(y - py);
            // Update best result if this is closer
            if (distance < minDistance) {
                minDistance = distance;
                bestIndex = i;
            }
        }
    }
    
    return bestIndex;
}

int main() {
    int x, y, n;
    scanf("%d %d %d", &x, &y, &n);
    
    int** points = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        points[i] = (int*)malloc(2 * sizeof(int));
        scanf("%d %d", &points[i][0], &points[i][1]);
    }
    
    printf("%d\n", nearestValidPoint(x, y, points, n));
    
    for (int i = 0; i < n; i++) {
        free(points[i]);
    }
    free(points);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Must examine each point once to check validity and calculate distance

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track the best result

✓ Linear Space

Constraints

1 ≤ points.length ≤ 10⁴
points[i].length == 2
1 ≤ x, y, ai, bi ≤ 10⁴
All coordinates are positive integers

28.5K Views

Medium Frequency

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

Linear Scan (Optimal Solution) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler