1779. 找到最近的有相同 X 或 Y 坐标的点

题目描述

给你两个整数 x 和 y ，表示你在一个笛卡尔坐标系下的 (x, y) 处。同时，在同一个坐标系下给你一个数组 points ，其中 points[i] = [ai, bi] 表示在 (ai, bi) 处有一个点。当一个点与你所在的位置有相同的 x 坐标或者相同的 y 坐标时，我们称这个点是 有效的 。

请返回距离你当前位置 曼哈顿距离 最近的 有效 点的下标（下标从 0 开始）。如果有多个最近的有效点，请返回下标 最小 的一个。如果没有有效点，请返回 -1 。

两个点 (x1, y1) 和 (x2, y2) 之间的 曼哈顿距离 为 abs(x1 - x2) + abs(y1 - y2) 。

示例

示例 1：

输入：x = 3, y = 4, points = [[1,2],[3,1],[2,4],[2,3],[4,4]]
输出：2
解释：所有点中，[3,1]，[2,4] 和 [4,4] 是有效点。有效点中，[2,4] 和 [4,4] 距离你当前位置的曼哈顿距离最小，都为 1 。[2,4] 的下标最小，所以返回 2 。
示例 2：

输入：x = 3, y = 4, points = [[3,4]]
输出：0
提示：答案可以与你当前所在位置坐标相同。
示例 3：

输入：x = 3, y = 4, points = [[2,3]]
输出：-1
解释：没有 有效点。

提示

1 <= points.length <= 104
points[i].length == 2
1 <= x, y, ai, bi <= 104

思路

1. 初始化min=10000，用于存储有效点的曼哈顿距离最小值。初始化minid=-1，用于存储返回的距离当前位置曼哈顿距离最近的有效点的下标.初始化tmp=-1，用于存储当前点的曼哈顿距离。
2. 遍历point数组寻找有效点
   3. 初始化pix用于存储point[i]横坐标，piy用于存储point[i]纵坐标,判断是否是有效点
   4. 计算当前有效点的曼哈顿距离存入tmp
   5. 如果当前有效点的曼哈顿距离tmp<min
   6. 更新min=当前有效点曼哈顿距离
   7. 更新minid=当前有效点下标

Java实现

class Solution {
    public int nearestValidPoint(int x, int y, int[][] points) {
        int i=0;
        // 1. 初始化min=10000，用于存储有效点的曼哈顿距离最小值。初始化minid=-1，用于存储返回的距离当前位置曼哈顿距离最近的有效点的下标.初始化tmp=-1，用于存储当前点的曼哈顿距离。
        int min = 10000;
        int minid = -1;
        int tmp = -1;
        //2. 遍历point数组寻找有效点
        for(i=0;i<points.length;i++)
        {
            //3.初始化pix用于存储point[i]横坐标，piy用于存储point[i]纵坐标,判断是否是有效点
            int pix = points[i][0];
            int piy = points[i][1];
            if(pix==x || piy==y)
            {
                // 4. 计算当前有效点的曼哈顿距离存入tmp
                tmp = Math.abs(pix-x)+Math.abs(piy-y);
                // 5. 如果当前有效点的曼哈顿距离tmp<min
                if(tmp<min)
                {
                    // 6. 更新min=当前有效点曼哈顿距离
                    min = tmp;
                    // 7. 更新minid=当前有效点下标
                    minid = i;
                }
            }
        }
        return minid;
    }
}

python实现

思路

• 1. 初始化min=10000，用于存储有效点的曼哈顿距离最小值。初始化minid=-1，用于存储返回的距离当前位置曼哈顿距离最近的有效点的下标.初始化tmp=-1，用于存储当前点的曼哈顿距离。
• 2. 遍历point数组寻找有效点
     • 3. 判断是否是横坐标相同的有效点
       • 4. 计算当前有效点的曼哈顿距离存入tmp
       • 5. 如果当前有效点的曼哈顿距离tmp<min
         • 6. 更新min=当前有效点曼哈顿距离
         • 7. 更新minid=当前有效点下标
     • 8. 判断是否是纵坐标相同的有效点
       • 9. 计算当前有效点的曼哈顿距离存入tmp
       • 10. 如果当前有效点的曼哈顿距离tmp<min
         • 11. 更新min=当前有效点曼哈顿距离
         • 12. 更新minid=当前有效点下标

class Solution:
    def nearestValidPoint(self, x: int, y: int, points: List[List[int]]) -> int:
        # 1. 初始化min=10000，用于存储有效点的曼哈顿距离最小值。初始化minid=-1，用于存储返回的距离当前位置曼哈顿距离最近的有效点的下标.初始化tmp=-1，用于存储当前点的曼哈顿距离。
        i=0
        n=len(points)
        min=10000
        minid=-1
        tmp=-1
        # 2. 遍历point数组寻找有效点
        for i, (pix,piy) in enumerate(points):
            # 3. 判断是否是横坐标相同的有效点
            if pix==x:
                # 4. 计算当前有效点的曼哈顿距离存入tmp
                tmp = abs(piy-y)
                # 5. 如果当前有效点的曼哈顿距离tmp<min
                if tmp<min:
                    # 6. 更新min=当前有效点曼哈顿距离
                    min = tmp
                    # 7. 更新minid=当前有效点下标
                    minid = i
            # 8. 判断是否是纵坐标相同的有效点
            if piy==y:
                # 9. 计算当前有效点的曼哈顿距离存入tmp
                tmp = abs(pix-x)
                # 10. 如果当前有效点的曼哈顿距离tmp<min
                if tmp<min:
                    # 11. 更新min=当前有效点曼哈顿距离
                    min = tmp
                    # 12. 更新minid=当前有效点下标
                    minid = i
        return minid

C++实现

class Solution {
public:
    int nearestValidPoint(int x, int y, vector<vector<int>>& points) {
        int n = points.size();
        int i = 0;
        //1. 初始化min=10000，用于存储有效点的曼哈顿距离最小值。初始化minid=-1，用于存储返回的距离当前位置曼哈顿距离最近的有效点的下标.初始化tmp=-1，用于存储当前点的曼哈顿距离。
        int min = 10000;
        int minid = -1;
        int tmp = -1;
        // 2. 遍历point数组寻找有效点
        for(i=0;i<n;i++)
        {
             //3.初始化pix用于存储point[i]横坐标，piy用于存储point[i]纵坐标,判断是否是有效点
             int pix = points[i][0];
             int piy = points[i][1];
             if(pix==x || piy==y)
             {
                 // 4. 计算当前有效点的曼哈顿距离存入tmp
                 tmp = abs(pix-x)+abs(piy-y);
                 // 5. 如果当前有效点的曼哈顿距离tmp<min
                 if(tmp<min)
                 {
                    // 6. 更新min=当前有效点曼哈顿距离
                    min = tmp;
                    // 7. 更新minid=当前有效点下标
                    minid = i;
                }
             }
        }
        return minid;
    }
};