| 
1 | 1 | package g0301_0400.s0373_find_k_pairs_with_smallest_sums;  | 
2 | 2 | 
 
  | 
3 | 3 | // #Medium #Array #Heap_Priority_Queue #Top_Interview_150_Heap  | 
4 |  | -// #2022_07_12_Time_59_ms_(46.79%)_Space_120.7_MB_(83.25%)  | 
 | 4 | +// #2025_03_09_Time_0_ms_(100.00%)_Space_57.66_MB_(90.88%)  | 
5 | 5 | 
 
  | 
 | 6 | +import java.util.AbstractList;  | 
6 | 7 | import java.util.ArrayList;  | 
 | 8 | +import java.util.Arrays;  | 
7 | 9 | import java.util.List;  | 
8 |  | -import java.util.PriorityQueue;  | 
9 | 10 | 
 
  | 
10 | 11 | public class Solution {  | 
11 |  | -    private static class Node {  | 
12 |  | -        long sum;  | 
13 |  | -        List<Integer> al;  | 
14 |  | -        int index;  | 
15 |  | - | 
16 |  | -        Node(int index, int num1, int num2) {  | 
17 |  | -            this.sum = (long) num1 + (long) num2;  | 
18 |  | -            this.al = new ArrayList<>();  | 
19 |  | -            this.al.add(num1);  | 
20 |  | -            this.al.add(num2);  | 
21 |  | -            this.index = index;  | 
22 |  | -        }  | 
23 |  | -    }  | 
24 |  | - | 
25 | 12 |     public List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {  | 
26 |  | -        PriorityQueue<Node> queue = new PriorityQueue<>((a, b) -> a.sum < b.sum ? -1 : 1);  | 
27 |  | -        List<List<Integer>> res = new ArrayList<>();  | 
28 |  | -        for (int i = 0; i < nums1.length && i < k; i++) {  | 
29 |  | -            queue.add(new Node(0, nums1[i], nums2[0]));  | 
30 |  | -        }  | 
31 |  | -        for (int i = 1; i <= k && !queue.isEmpty(); i++) {  | 
32 |  | -            Node cur = queue.poll();  | 
33 |  | -            res.add(cur.al);  | 
34 |  | -            int next = cur.index;  | 
35 |  | -            int lastNum1 = cur.al.get(0);  | 
36 |  | -            if (next + 1 < nums2.length) {  | 
37 |  | -                queue.add(new Node(next + 1, lastNum1, nums2[next + 1]));  | 
 | 13 | +        return new AbstractList<List<Integer>>() {  | 
 | 14 | +            private List<List<Integer>> pairs;  | 
 | 15 | + | 
 | 16 | +            @Override  | 
 | 17 | +            public List<Integer> get(int index) {  | 
 | 18 | +                init();  | 
 | 19 | +                return pairs.get(index);  | 
 | 20 | +            }  | 
 | 21 | + | 
 | 22 | +            @Override  | 
 | 23 | +            public int size() {  | 
 | 24 | +                init();  | 
 | 25 | +                return pairs.size();  | 
 | 26 | +            }  | 
 | 27 | + | 
 | 28 | +            private void load() {  | 
 | 29 | +                int n = nums1.length;  | 
 | 30 | +                int m = nums2.length;  | 
 | 31 | +                int left = nums1[0] + nums2[0];  | 
 | 32 | +                int right = nums1[n - 1] + nums2[m - 1];  | 
 | 33 | +                int middle;  | 
 | 34 | + | 
 | 35 | +                while (left <= right) {  | 
 | 36 | +                    middle = (left + right) / 2;  | 
 | 37 | +                    long count = getCount(nums1, nums2, middle, k);  | 
 | 38 | +                    if (count < k) {  | 
 | 39 | +                        left = middle + 1;  | 
 | 40 | +                    } else if (count > k) {  | 
 | 41 | +                        right = middle - 1;  | 
 | 42 | +                    } else {  | 
 | 43 | +                        left = middle;  | 
 | 44 | +                        break;  | 
 | 45 | +                    }  | 
 | 46 | +                }  | 
 | 47 | +                getPairs(nums1, nums2, left, k);  | 
 | 48 | +            }  | 
 | 49 | + | 
 | 50 | +            private long getCount(int[] nums1, int[] nums2, int goal, int k) {  | 
 | 51 | +                int prevRight = nums2.length - 1;  | 
 | 52 | +                int count = 0;  | 
 | 53 | + | 
 | 54 | +                for (int i = 0; i < nums1.length && nums1[i] + nums2[0] <= goal; i++) {  | 
 | 55 | +                    int left = 0;  | 
 | 56 | +                    int right = prevRight;  | 
 | 57 | +                    int position = -1;  | 
 | 58 | +                    while (left <= right) {  | 
 | 59 | +                        int middle = (right + left) / 2;  | 
 | 60 | +                        int sum = nums1[i] + nums2[middle];  | 
 | 61 | +                        if (sum <= goal) {  | 
 | 62 | +                            position = middle;  | 
 | 63 | +                            left = middle + 1;  | 
 | 64 | +                        } else {  | 
 | 65 | +                            right = middle - 1;  | 
 | 66 | +                        }  | 
 | 67 | +                    }  | 
 | 68 | +                    if (position >= 0) {  | 
 | 69 | +                        count += position + 1;  | 
 | 70 | +                        prevRight = position;  | 
 | 71 | +                    }  | 
 | 72 | +                    if (count > k) {  | 
 | 73 | +                        return count;  | 
 | 74 | +                    }  | 
 | 75 | +                }  | 
 | 76 | +                return count;  | 
 | 77 | +            }  | 
 | 78 | + | 
 | 79 | +            private void getPairs(int[] nums1, int[] nums2, int sum, int k) {  | 
 | 80 | +                pairs = new ArrayList<>();  | 
 | 81 | +                for (int item : nums1) {  | 
 | 82 | +                    for (int j = 0; j < nums2.length && item + nums2[j] < sum; j++) {  | 
 | 83 | +                        pairs.add(Arrays.asList(item, nums2[j]));  | 
 | 84 | +                    }  | 
 | 85 | +                }  | 
 | 86 | +                for (int value : nums1) {  | 
 | 87 | +                    for (int j = 0;  | 
 | 88 | +                            j < nums2.length && value + nums2[j] <= sum && pairs.size() < k;  | 
 | 89 | +                            j++) {  | 
 | 90 | +                        if (value + nums2[j] == sum) {  | 
 | 91 | +                            pairs.add(Arrays.asList(value, nums2[j]));  | 
 | 92 | +                        }  | 
 | 93 | +                    }  | 
 | 94 | +                }  | 
 | 95 | +            }  | 
 | 96 | + | 
 | 97 | +            public void init() {  | 
 | 98 | +                if (null == pairs) {  | 
 | 99 | +                    load();  | 
 | 100 | +                }  | 
38 | 101 |             }  | 
39 |  | -        }  | 
40 |  | -        return res;  | 
 | 102 | +        };  | 
41 | 103 |     }  | 
42 | 104 | }  | 
0 commit comments