【Leetcode】719. Find K-th Smallest Pair Distance

Subject address:

https://leetcode.com/problems/find-k-th-smallest-pair-distance/

Given a length nnArray of$n$$A$ , given two unequal subscripts$i$ and$j$ , we can always calculate the number pair difference$|A[i]-A[j]|$ . Given a positive integer$k$ , askkkWhat is the difference of such a number with small$k$ ? The order of the subscripts is different, it is also regarded as the same number pair.

The idea is a dichotomous answer. If AAThe maximum value of$A$ is$M$ , the minimum value is$m$ , the biggest difference is obviously$M-m$ , the minimum difference is$0$ . We can divide the answer into two divisions, each time a number$x$ , just look at how many pairs of numbers are less than or equal to it, if it is greater than or equal to$k$ , then the final answer is not greater than$x$ , then shrink the right margin to$x$ ; otherwise, the final answer is greater than$x$ , then shrink the left margin to$x+1$ . Calculation ratioxxThe number of$x$ less than or equal to the number of differences can be done with sort + double pointer. After sorting the array, open two pointers$i$ and$j$ keep$i>j$ (because the number pair cannot be repeated), if the number pair difference is greater than$x$ , then move the left pointer to the right until the logarithmic difference is less than or equal to or$j=i$ until$i$ , and then accumulate$i-j$ (here$i-j$ Ze以$A\left[i\right]$ is the larger value and the logarithmic difference is less than or equal toxxThe number of pairs of$x$ ). Note that there is no need to roll back the left pointer. The reason is that rollback will only result in a larger number-to-pair difference and no answer. code show as below:

import java.util.Arrays;

public class Solution {
    
    
    public int smallestDistancePair(int[] nums, int k) {
    
    
        if (nums == null || nums.length == 0) {
    
    
            return 0;
        }
        
        Arrays.sort(nums);
        
        int l = 0, r = nums[nums.length - 1] - nums[0];
        while (l < r) {
    
    
            int m = l + (r - l >> 1);
            // 计算一下小于等于m的数对差的个数
            int count = 0;
            for (int i = 0, j = 0; i < nums.length; i++) {
    
    
                while (j < i && nums[i] - nums[j] > m) {
    
    
                    j++;
                }
                
                count += i - j;
            }
            
            // 如果小于等于m的数对差的个数大于等于k，则收缩右边界，否则收缩左边界
            if (count >= k) {
    
    
                r = m;
            } else {
    
    
                l = m + 1;
            }
        }
        
        return l;
    }
}

Time complexity $O(n(\log (M-m)+n))$，$M$ is the maximum value of the array,$m$ is the minimum value of the array, space$O\left(1\right)$。