滑动窗口系列：最接近的K个数，最接近的三个数之和， 最接近原点的 K 个点

LeetCode 658. 找到 K 个最接近的元素

给定一个排序好的数组 arr ，两个整数 k 和 x ，从数组中找到最靠近 x（两数之差最小）的 k 个数。返回的结果必须要是按升序排好的。

整数 a 比整数 b 更接近 x 需要满足：

|a - x| < |b - x| 或者
|a - x| == |b - x| 且 a < b

示例 1：
输入：arr = [1,2,3,4,5], k = 4, x = 3
输出：[1,2,3,4]

示例 2：
输入：arr = [1,2,3,4,5], k = 4, x = -1
输出：[1,2,3,4]

提示：
1 <= k <= arr.length
1 <= arr.length <= $10^4$
数组里的每个元素与 x 的绝对值不超过 $10^4$

解题思路：滑动窗口

1. 由于数组已排好序，所以离x最远的元素一定在数组两端。
2. 两个指针，一个指针$left$指着第一个元素，一个指针$right$指着最后一个元素。
3. 如果 right - left >= k，那就说明窗口中元素个数大于k，那么就删除一个离x更远的元素，如果一样远，就删除大的元素。一直删到窗口中只剩k个元素为止。
4. 时间复杂度: O(n), 空间复杂度: O(1)

• 代码如下:

class Solution:
    def findClosestElements(self, arr: List[int], k: int, x: int) -> List[int]:
        left,right = 0, len(arr)-1
        while right - left >= k:
            if x - arr[left] <= arr[right] - x:
                right = right - 1
            else:
                left = left + 1
        return arr[left:left+k]

解题思路2：二分法

• 长度为k的窗口一定是通过长度为k+1的窗口删除首尾之一元素得到的。
• 观察某一个特定的长度为k+1 的窗口[left,left+k] ，如果arr[left]离x距离比arr[left+k]离x更远的话，那就要删除arr[left]，同时说明left以及它左边的所有元素都不可能是答案窗口的左边界。
• 反之如果arr[left]离x距离小于等于arr[left+k]离 x的距离，那么就要删除arr[left+k]了，同时说明left右边的元素都不可能是答案窗口的左边界。
• 综上，我们可以用二分直接寻找答案窗口的左边界。这样时间复杂度就降到O(log(n))
• 代码如下:

class Solution:
    def findClosestElements(self, arr: List[int], k: int, x: int) -> List[int]:
        left,right = 0, len(arr)-k
        while left < right:
            mid = left + (right - left) //2
            if x - arr[mid] <= arr[mid+k] - x:
                right = mid
            else:
                left = mid + 1
        return arr[left:left+k]

16. 最接近的三个数之和

给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

示例：
输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

提示：
$3<=nums.length<=10^3$
$-10^3<=nums[i]<=10^3$
$-10^4<=target<=10^4$

滑动窗口

class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        nums = sorted(nums)
        ans = nums[0] + nums[1] + nums[2]
        for i in range(0,len(nums)):
            start, end = i + 1, len(nums) - 1
            while(start < end):
                temp = nums[i] + nums[start] + nums[end]
                if(abs(target-temp) < abs(target - ans)):
                    ans = temp
                elif(temp > target):
                    end = end - 1
                elif(temp <target):
                    start = start + 1
                else:
                    return ans
        return ans

• C++

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        int ans = nums[0] + nums[1] + nums[2];
        for(int i=0;i<nums.size();i++) {
            int start = i+1, end = nums.size() - 1;
            while(start < end) {
                int sum = nums[start] + nums[end] + nums[i];
                if(abs(target - sum) < abs(target - ans))
                    ans = sum;
                if(sum > target)
                    end--;
                else if(sum < target)
                    start++;
                else
                    return ans;
            }
        }
        return ans;
    }
};

LeetCode 973. 最接近原点的 K 个点

我们有一个由平面上的点组成的列表 points。需要从中找出 K 个距离原点 (0, 0) 最近的点。（这里，平面上两点之间的距离是欧几里德距离。）

• 你可以按任何顺序返回答案。除了点坐标的顺序之外，答案确保是唯一的。

示例 1：
输入：points = [[1,3],[-2,2]], K = 1
输出：[[-2,2]]
解释：
(1, 3) 和原点之间的距离为 sqrt(10)，
(-2, 2) 和原点之间的距离为 sqrt(8)，
由于 sqrt(8) < sqrt(10)，(-2, 2) 离原点更近。
我们只需要距离原点最近的 K = 1 个点，所以答案就是 [[-2,2]]。

示例 2：
输入：points = [[3,3],[5,-1],[-2,4]], K = 2
输出：[[3,3],[-2,4]]
（答案 [[-2,4],[3,3]] 也会被接受。）

提示：
1 <= K <= points.length <= 10000
-10000 < points[i][0] < 10000
-10000 < points[i][1] < 10000

解题思路：直接排序取前K个即可

class Solution:
    def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
        points.sort(key=lambda x: (x[0] ** 2 + x[1] ** 2))
        return points[:k]