719. Find K-th Smallest Pair Distance

1 题目理解

输入：一个int数组nums，一个数字k
输出：返回所有数字对中，数字对距离第k小的距离。
规则：一个数组中两两配对计算差值得到距离。距离值从小到大排序，第k位置的元素就是返回值。
例如
Input:
nums = [1,3,1]
k = 1
Output: 0
所有的配对距离是:
(1,3) -> 2
(1,1) -> 0
(3,1) -> 2
所有距离中从小到大排序，第1个是0，所以返回0。

Note:

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

2 分析思路

内容来源于花花酱。

2.1 桶排序

最直接的想法是用两个for循环计算每个匹配对的距离，然后对距离进行排序。返回第k个元素 。排序算法选择桶排序，加快速度。int[] distance记录距离出现的次数。distance[0]表示有几个配对的距离为0。

class Solution {
    public int smallestDistancePair(int[] nums, int k) {
        Arrays.sort(nums);
        int n = nums.length;
        int  max = nums[n-1];
        int[] distance = new int[max+1];
        for(int i=0;i<n;i++){
            for(int j=i+1;j<n;j++){
                distance[nums[j] - nums[i]]++;
            }
        }
        for(int i = 0;i<max;i++){
            k -= distance[i];
            if(k<=0){
                return i;
            }
        }
        return 0;
    }
}

时间复杂度$O(n^{2}max)$

2.2 二分+动态规划

我们先对数组nums排序。
返回值最小值是0，最大值=nums最大值-nums最小值。
用二分法查找返回值，也就是距离。
例如m=3，我们需要查找有多少个配对的距离小于等于3。
查找的方法使用动态规划。
设dp[0] 为所有和nums[0]配对的距离小于等于3，有多少个。
dp[1]为所有和nums[0],nums[1]的配对距离小于等于3，有多少个。
…
dp[n-1]表示所有配对中距离小于等于3，有多少个。
例如nums={1,1,3,5,8}。
最开始，i=0，j=0，
nums[0] - nums[0] =0<=m，成立，j++；
nums[1]-nums[0]=1-1=0<=m，成立，j++；
nums[2]-nums[0]=3-1=2<=m,成立，j++;
nums[3]-nums[0]=5-1=4<=m，不成立，退出循环，因为数组是有序的，再比较下去，距离只会越来越大。
那么dp[0] = j-i-1=3-0-1=2，表示所有和nums[0]配对中，有2个配对的距离<=m。

接着计算i=1，此时j不需要从0开始。

配对(0,2)在上一步已经计算了，配对(1,2)的距离一定<=m。
因为nums[2]-nums[0]<=m，在上一步已经计算过了，而nums[1]>nums[0]，同样的数减去一个更大的数，差只能更小。
所以j不需要从0开始。

j=3，nums[3]-nums[1]=5-1=4<=m，不成立，退出循环。
dp[1] = dp[0] + (j-i-1)=3，表示所有和nums[0]、nums[1]配对中，有3个配对的距离<=m。

接着计算i=4，j=3。
…

class Solution {
    public int smallestDistancePair(int[] nums, int k) {
        Arrays.sort(nums);
        int n = nums.length;
        int l = 0;
        int r = nums[n-1]-nums[0];
        while(l<=r){
            int m =  l+((r-l)>>1);
            if(countNumber(nums,m)>=k){
                r = m - 1;
            }else{
                l = m + 1;
            }
        }
                 
        return l;
    }
    
    private int countNumber(int[] nums,int m){
        int j = 0;
        int n = nums.length;
        int[] dp = new int[n];
        for(int i=0;i<n;i++){
            while(j<n && nums[j]-nums[i]<=m) j++;
            dp[i] = ( i==0? (j-i-1) : dp[i-1]+(j-i-1));
        }
        return dp[n-1];
    }
}

时间复杂度$O(nlogn)$，n应该是数组长度和数组最大值之间的最大值。当然最后的代码还可以做空间优化。

2.3 用堆实现

参考力扣
首先将数组排序，排序之后，相邻元素的差最小。先将nums[i]和nums[i+1]，放入堆中，之后再依次将nums[i]和nums[i+2] nums[i]和nums[i+3]放入堆中 …
时间复杂度O((k+N)lgN)，时间复杂度过高。

class Solution {
    public int smallestDistancePair(int[] nums, int k) {
        Arrays.sort(nums);
        PriorityQueue<Node> heap = new PriorityQueue<Node>(nums.length,
            Comparator.<Node> comparingInt(node -> nums[node.nei] - nums[node.root]));
        
        int n = nums.length;
        for(int i=0;i<n-1;i++){
            heap.offer(new Node(i,i+1));
        }
        Node node = null;
        for(;k>0;k--){
            node = heap.poll();            
            if(node.nei+1<n){
                heap.offer(new Node(node.root,node.nei+1));
            }
        }
        return nums[node.nei]- nums[node.root];
    }
    class Node {
        int root;
        int nei;
        Node(int r, int n) {
            root = r;
            nei = n;
        }
    }

}

3相似题目786

3.1 二分

虽说相似，没有找到规律还是理解不了的。即使找到规律了也不一定会数数，在O(n)时间复杂度内。

class Solution {
    public int[] kthSmallestPrimeFraction(int[] A, int K) {
        double l = 0;
        double r = 1.0;
        int[] answer = new int[2];
        while(l<r){
            double m = (l+r)/2;
            int[] res = countSmallerOrEqual(A,m);
            if(res[0] == K){
                answer[0] = res[1];
                answer[1] = res[2];
                break;
            }else if(res[0]>=K){
                r = m;
            }else{
                l = m;
            }
        }
        return answer;
    }
    
    private int[] countSmallerOrEqual(int[] A,double m){
        int count = 0;
        int p = 0,q = 1;
        int i=0;
        for(int j=1;j<A.length;j++){
            while(A[i]<=m*A[j]) i++;
            count += i;
            if(i>0){
                i=i-1;
                if(p*A[j]<q*A[i]){
                    p = A[i];
                    q = A[j];
                }
            }
            
        }
        return new int[]{count, p, q};
    }
   
}

对于countSmallerOrEqual函数不知道怎么写，可以先用两个for循环来写。会发现i的循环可以提取出来。因为A数组是递增的。例如[1,2,3,5]。如果1/2满足条件，那么1/3一定满足条件。因为分子不变，分母增加，数值会越来越小。

private int[] countSmallerOrEquals(int[] A ,double m){
    	int count = 0;
        int p = 0,q = 1;
        for(int j=1;j<A.length;j++){
            int i=0;
            for(;i<j;i++){
                if(A[i]>m*A[j]){
                    break;
                }
            }
            count += i;
            i=i-1;
            if(p*A[j]<q*A[i]){
                p = A[i];
                q = A[j];
            }
        }
        return new int[]{count, p, q};
    }

3.2 堆

class Solution {
    public int[] kthSmallestPrimeFraction(int[] A, int k) {
        int[] answer = new int[2];
        PriorityQueue<int[]> pq = new PriorityQueue<int[]>((a, b) ->
        A[a[0]] * A[b[1]] - A[a[1]] * A[b[0]]);
        
        for(int i=1;i<A.length;i++){
            pq.offer(new int[]{0,i});
        }
        
        while(k>1){
            int[] vals = pq.poll();
            if(vals[0]+1 < vals[1]){
                pq.offer(new int[]{vals[0]+1,vals[1]});
            }
            k--;
        }
        answer = pq.poll();
        return new int[]{A[answer[0]],A[answer[1]]};
    }
  
}