Formatted question description: https://leetcode.ca/all/1779.html

# 1779. Find Nearest Point That Has the Same X or Y Coordinate

## Level

Easy

## Description

You are given two integers, `x`

and `y`

, which represent your current location on a Cartesian grid: `(x, y)`

. You are also given an array `points`

where each `points[i] = [a_i, b_i]`

represents that a point exists at `(a_i, b_i)`

. A point is **valid** if it shares the same x-coordinate or the same y-coordinate as your location.

Return *the index (0-indexed) of the valid point with the smallest Manhattan distance from your current location*. If there are multiple, return

*the valid point with the*. If there are no valid points, return

**smallest**index`-1`

.The **Manhattan distance** between two points `(x_1, y_1)`

and `(x_2, y_2)`

is `abs(x_1 - x_2) + abs(y_1 - y_2)`

.

**Example 1:**

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

**Output:** 2

**Explanation:** Of all the points, only [3,1], [2,4] and [4,4] are valid. Of the valid points, [2,4] and [4,4] have the smallest Manhattan distance from your current location, with a distance of 1. [2,4] has the smallest index, so return 2.

**Example 2:**

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

**Output:** 0

**Explanation:** The answer is allowed to be on the same location as your current location.

**Example 3:**

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

**Output:** -1

**Explanation:** There are no valid points.

**Constraints:**

`1 <= points.length <= 10^4`

`points[i].length == 2`

`1 <= x, y, a_i, b_i <= 10^4`

## Solution

Loop over all points in `points`

. For each point, if it is valid, calculate the Manhattan distance from `(x, y)`

and update the smallest distance and the index if the current distance is smaller. Finally, return the index (or -1 if no point is valid).

```
class Solution {
public int nearestValidPoint(int x, int y, int[][] points) {
int minIndex = -1;
int minDistance = Integer.MAX_VALUE;
int length = points.length;
for (int i = 0; i < length; i++) {
int[] point = points[i];
if (x == point[0] || y == point[1]) {
int distance = manhattanDistance(x, y, point);
if (distance < minDistance) {
minIndex = i;
minDistance = distance;
}
}
}
return minIndex;
}
public int manhattanDistance(int x, int y, int[] point) {
return Math.abs(x - point[0]) + Math.abs(y - point[1]);
}
}
```