leetcode719. 找出第 k 小的距离对（Java）

题目

给定一个整数数组，返回所有数对之间的第 k 个最小距离。一对 (A, B) 的距离被定义为 A 和 B 之间的绝对差值。

示例 1:

输入：
nums = [1,3,1]
k = 1
输出：0
解释：
所有数对如下：
(1,3) -> 2
(1,1) -> 0
(3,1) -> 2
因此第 1 个最小距离的数对是 (1,1)，它们之间的距离为 0。
提示:

2 <= len(nums) <= 10000.
0 <= nums[i] < 1000000.
1 <= k <= len(nums) * (len(nums) - 1) / 2.

思路分析

  要求第几个最小的值，首先想到的就是利用最小堆。本题要求第 k 个最小距离，初始思路是，求出所有数对，按照数对之间的距离排序。可以把这些数对存成对象，利用最小堆对其排序，然后在堆中依次取出前 k 个数对。这样做的结果就是内存超限。该思路的代码我会放在最后，仅供参考。
  再者就是利用二分搜索，数对间的距离是有限的，其范围在 (0, max-min)。其中max指的是数组 nums 中的最大值，min是数组 nums 中的最小值。只需要在该范围内，找到一个距离 d ，如果小于等于d的数对的个数 大于等于 k，那么说明这个距离 d 符合题目要求。我们可以这样理解，题目要求找到前 k 个最小的距离，需要找到某个距离 d ，小于等于 d 的距离数为 k ，由于可能有多个距离的大小是一样的，所以如果小于等于 d 的距离数大于 k 也是符合条件的。但是注意应该首先找到等于 k 的，如果不可以才去找大于 k 的。
   对于上述思路，利用二分搜索找到 一个 d ，小于等于距离 d 的数对大于等于 k 。可以据此写一个简单的二分搜索模型

/**
     * 已知，nums[right] >= target总是成立
     * 搜索结束时，无论如何都满足left = right = mid，结束时有两种情况：
     *      1、从 left = mid + 1 结束，此时left = right，又因为nums[right] >= target
     *      2、从 right = mid 结束，此时left = right，又因为nums[right] >= target
     * 以上两种情况得到的结果都是 nums[left] = nums[right] >= target
     * right = left 是大于等于target的位置，注意不会超过nums.length - 1
     * @param nums
     * @param target
     * @return
*/
public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] < target)
                left = mid + 1;
            else
                right = mid;
        }
        return left;
    }

  然后不断判断 小于等于距离 d 的数对个数是否 >= k 即可。在计算小于等于距离 d 的数对个数时，需要注意如果我们对数组进行排序，然后使用左右指针来判断 left 和 right 这两个数的距离是否符合要求，因为数组已经排序过，所以每次判断完成之后，right 不需要重置。
代码如下：

class Solution {
    public int smallestDistancePair(int[] nums, int k) {
        Arrays.sort(nums);
        int left = 0;
        int right = nums[nums.length - 1] - nums[0];
        while (left < right) {
            int mid = left + (right - left) / 2;
            int ans = find(nums, mid);
            if (ans < k) {
                left = mid + 1;
            } else
                right = mid;
        }
        return left;
    }

    private int find(int[] nums, int target) {
        int count = 0;
        int right = 0;
        for (int left = 0; left < nums.length; left++) {
            while (right + 1 < nums.length && nums[right + 1] - nums[left] <= target) {
                right++;
            }
            count += right - left;
        }
        return count;
    }
}

附

使用最小堆的超内存方法：

class Solution {
    
    private class Pair {
        int A;
        int B;
        int diff;
        Pair(int A, int B) {
            this.A = A;
            this.B = B;
            this.diff = Math.abs(A - B);
        }
    }
    
    public int smallestDistancePair(int[] nums, int k) {
        Queue<Pair> minHeap = new PriorityQueue<>(new Comparator<Pair>() {
            @Override
            public int compare(Pair o1, Pair o2) {
                return o1.diff - o2.diff;
            }
        });
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                minHeap.offer(new Pair(nums[i], nums[j]));
            }
        }
        int res = 0;
        while (k > 0) {
            res = minHeap.poll().diff;
            k--;
        }
        return res;
    }
}