Updates leetcode/binary-search/719-find-k-th-smallest-pair-distance.md

Auto commit by GitBook Editor

Author: just4once

SUMMARY.md

@@ -259,6 +259,7 @@
     * [704-Binary Search](leetcode/binary-search/704-binary-search.md)
     * [710-Random Pick with Blacklist](leetcode/binary-search/710-random-pick-with-blacklist.md)
     * [718-Maximum Length of Repeated Subarray](leetcode/binary-search/718-maximum-length-of-repeated-subarray.md)
+    * [719-Find K-th Smallest Pair Distance](leetcode/binary-search/719-find-k-th-smallest-pair-distance.md)
 * [Template](template.md)
   * [LeetCode](template/leetcode.md)
 * [Other](other.md)

leetcode/binary-search/528-random-pick-with-weight.md

@@ -4,7 +4,7 @@
 
 Given an array w of positive integers, where w\[i\] describes the weight of index i, write a function pickIndex which randomly picks an index in proportion to its weight.
 
-**Note:    
+**Note:      
 **
 
 1. 1 <= w.length <= 10000
@@ -29,7 +29,7 @@ Input:
 Output: [null,0,1,1,1,0]
 ```
 
-**Explanation of Input Syntax:    
+**Explanation of Input Syntax:      
 **
 
 The input is two lists: the subroutines called and their arguments. Solution's constructor has one argument, the array w. pickIndex has no arguments. Arguments are always wrapped with a list, even if there aren't any.
@@ -95,7 +95,7 @@ class Solution {
             map.put(total, i);
         }
     }
-    
+
     public int pickIndex() {
         int k = map.higherKey(rand.nextInt(total));
         return map.get(k);

leetcode/binary-search/719-find-k-th-smallest-pair-distance.md

@@ -0,0 +1,91 @@
+### Question {#question}
+
+[https://leetcode.com/problems/find-k-th-smallest-pair-distance/description/](https://leetcode.com/problems/find-k-th-smallest-pair-distance/description/)
+
+Given an integer array, return the k-th smallest distance among all the pairs. The distance of a pair \(A, B\) is defined as the absolute difference between A and B.
+
+**Example:**
+
+```
+Input:
+nums = [1,3,1]
+k = 1
+Output: 0 
+Explanation:
+Here are all the pairs:
+(1,3) -> 2
+(1,1) -> 0
+(3,1) -> 2
+Then the 1st smallest distance pair is (1,1), and its distance is 0.
+```
+
+**Note:**
+
+1. 2 <= len\(nums\) <= 10000.
+2. 0 <= nums\[i\] < 1000000.
+3. 1 <= k <= len\(nums\) \* \(len\(nums\) - 1\) / 2.
+
+### Thought Process {#thought-process}
+
+1. Brute Force \(TLE\)
+   1. Generate all the distance pairs through n^2 process
+   2. Sort the distances and return the k-th distance by returning distance\[k - 1\]
+   3. Time complexity O\(n^2\)
+   4. Space complexity O\(n^2\)
+2. Heap \(TLE\)
+   1. Sort the nums array and save all the adjacent pairs as nodes into the minHeap
+   2. Every time, we poll the min distance pair out and save the next pair
+   3. After looping for k times, the top node in the heap will contain the pair with kth distance
+   4. Time complexity O\(nlogn + kLogn\)
+   5. Space complexity O\(n\)
+3. asd
+
+### Solution
+
+```java
+class Solution {
+    public int smallestDistancePair(int[] nums, int k) {
+        int n = nums.length;
+        int[] distances = new int[n * (n - 1) / 2];
+        int z = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                distances[z++] = Math.abs(nums[i] - nums[j]);
+            }
+        }
+        Arrays.sort(distances);
+        return distances[k - 1];
+    }
+}
+```
+
+```java
+class Solution {
+    private static class Node {
+        int i, j;
+        public Node(int i, int j) {
+            this.i = i;
+            this.j = j;
+        }
+    }
+    
+    public int smallestDistancePair(int[] nums, int k) {
+        Arrays.sort(nums);
+        PriorityQueue<Node> minHeap = new PriorityQueue<>((a, b) -> (nums[a.j] - nums[a.i]) - (nums[b.j] - nums[b.i]));
+        for (int i = 0; i + 1 < nums.length; i++) {
+            minHeap.offer(new Node(i, i + 1));
+        }
+        Node cur = null;
+        while (k-- > 0) {
+            cur = minHeap.poll();
+            if (cur.j + 1 < nums.length) minHeap.offer(new Node(cur.i, cur.j + 1));
+        }
+        return nums[cur.j] - nums[cur.i];
+    }
+}
+```
+
+### Additional {#additional}
+
+
+