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`

represents that a point exists at _{i}, b_{i}]`(a`

. A point is _{i}, b_{i})**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

`-1`

.The **Manhattan distance** between two points `(x`

and _{1}, y_{1})`(x`

is _{2}, y_{2})`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:2Explanation: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:0Explanation: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:-1Explanation:There are no valid points.

**Constraints:**

`1 <= points.length <= 10`

^{4}`points[i].length == 2`

`1 <= x, y, a`

_{i}, b_{i}<= 10^{4}

```
struct Solution;
impl Solution {
fn nearest_valid_point(x: i32, y: i32, points: Vec<Vec<i32>>) -> i32 {
let n = points.len();
let mut res: Option<(i32, usize)> = None;
for i in 0..n {
if points[i][0] == x || points[i][1] == y {
let dist = (points[i][0] - x).abs() + (points[i][1] - y).abs();
if let Some((min_dist, min_index)) = res {
res = Some((min_dist, min_index).min((dist, i)));
} else {
res = Some((dist, i));
}
}
}
if let Some((_, min_index)) = res {
min_index as i32
} else {
-1
}
}
}
#[test]
fn test() {
let x = 3;
let y = 4;
let points = vec_vec_i32![[1, 2], [3, 1], [2, 4], [2, 3], [4, 4]];
let res = 2;
assert_eq!(Solution::nearest_valid_point(x, y, points), res);
let x = 3;
let y = 4;
let points = vec_vec_i32![[3, 4]];
let res = 0;
assert_eq!(Solution::nearest_valid_point(x, y, points), res);
let x = 3;
let y = 4;
let points = vec_vec_i32![[2, 3]];
let res = -1;
assert_eq!(Solution::nearest_valid_point(x, y, points), res);
}
```