【力扣时间】【373】【中等】查找和最小的K对数字

最新推荐文章于 2024-06-15 09:23:13 发布

社畜菌

最新推荐文章于 2024-06-15 09:23:13 发布

阅读量98

点赞数

分类专栏：我的算法历程文章标签： leetcode 算法

本文链接：https://blog.csdn.net/qq_19917031/article/details/122499921

版权

我的算法历程专栏收录该内容

41 篇文章 0 订阅

订阅专栏

查找和最小的K对数字

又到周五了，不过今天的中等题稍微有些动脑哦。

1、读题

我是题

言简意赅。

2、审题

题目给的信息很少，但足够表述清楚题意。
而你也能很轻松地发现这题的考点和难点。

但我们先说重点：

提供的两个数组是保证升序的
数组内可能存在相同的数字
两个数组组成的所有数对可能都不够K个（见示例3）

3、思路

最简单无脑暴力的思路，当然是嵌套循环，将两个数组的每个元素组成笛卡尔积，塞到一个优先级队列里，然后依次取出前K个。

很明显，在1 <= nums1.length, nums2.length <= 10⁵ 的条件下，这种思路多半是超时的。
即使不超时，耗时排名也会很难堪。

有这种想法绝不是坏事，它虽然朴素，但却能成为好的思路的跳板。
由于题目给出的K的范围最大是1000，所以一股脑把所有元素的笛卡尔积全部塞进去是很浪费的，于是我们可以一个个塞进去。

由于题目保证了nums1和nums2是严格升序的，所以很明显，（nums1[0],nums2[0]）是最小的数对。
而在此基础上，可能第二小的数对将存在于（nums1[1],nums2[0]）或（nums1[0],nums2[1]）之中。

于是，我们可以实现一个优先级队列，用于存放最小数对的下标，每次取出当前最小的数对，假设为（i,j），则在（i,j）之后，比他稍大一点的数对可能为（i,j+1）或（i+1,j），将它们全部添加到优先级队列中，并重复此过程，直到出队的的数量达到K，或队列已空。

4、动手吧！

class Solution {
    public List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {
        List<List<Integer>> result = new ArrayList<>();
        Set<Integer> vis = new HashSet<>();
        Queue<int[]> queue = new PriorityQueue<>((o1, o2) -> nums1[o1[0]] + nums2[o1[1]] - nums1[o2[0]] - nums2[o2[1]]);
        queue.add(new int[]{0, 0});

        while (result.size() < k && !queue.isEmpty()) {
            int[] pair = queue.poll();
            int i = pair[0], j = pair[1];

            int p = i * 10000 + j;
            //已访问则跳过
            if (vis.contains(p)) {
                continue;
            }

            //添加当前对到结果中
            result.add(Arrays.asList(nums1[i], nums2[j]));
            //也标记为已访问
            vis.add(p);

            //当nums1未抵达边界时，提交nums2的当前数和nums1的下一个数
            if (i + 1 < nums1.length) {
                queue.add(new int[]{i + 1, j});
            }
            //当nums2未抵达边界时，提交nums1的当前数和nums2的下一个数
            if (j + 1 < nums2.length) {
                queue.add(new int[]{i, j + 1});
            }
        }

        return result;
    }
}

5、解读

正如我之前所说，我们可以通过优先级队列来实时获取当前最小的数对。
于是，我实现了一个元素为int[]的优先级队列，每一个int[]包含了两个数，即为当前nums1[]和nums2[]的下标。
毕竟我们不仅要获取当前最小数对，还得获取可能的下一个最小数对，即（i,j+1）或（i+1,j）。

 Queue<int[]> queue = new PriorityQueue<>((o1, o2) -> nums1[o1[0]] + nums2[o1[1]] - nums1[o2[0]] - nums2[o2[1]]);
 queue.add(new int[]{0, 0});

然后，就是不停地从队列中取出当前最小数对，并往队列里放入下一个个可能的最小数对

while (result.size() < k && !queue.isEmpty()) {
    int[] pair = queue.poll();
    int i = pair[0], j = pair[1];

    int p = i * 10000 + j;
    //已访问则跳过
    if (vis.contains(p)) {
        continue;
    }

    //添加当前对到结果中
    result.add(Arrays.asList(nums1[i], nums2[j]));
    //也标记为已访问
    vis.add(p);

    //当nums1未抵达边界时，提交nums2的当前数和nums1的下一个数
    if (i + 1 < nums1.length) {
        queue.add(new int[]{i + 1, j});
    }
    //当nums2未抵达边界时，提交nums1的当前数和nums2的下一个数
    if (j + 1 < nums2.length) {
        queue.add(new int[]{i, j + 1});
    }
}

循环的跳出条件则是达到K个数量，或是队列已空，即数组组成的数对不够K个时。

由于在添加次小数对时，是可能存在重复的，所以我还额外使用了一个Set来去重。里面存放了已经访问过了的下标对。
由于题目限制了nums1和nums2的长度最大只有10⁵，所以我将数对中nums1的下标i放大了10000倍，并和nums2的下标j相加，化二维为一维。

    Set<Integer> vis = new HashSet<>();

	……
	……
	
	int p = i * 10000 + j;
	//已访问则跳过
	if (vis.contains(p)) {
		continue;
	}
	
	//添加当前对到结果中
	result.add(Arrays.asList(nums1[i], nums2[j]));
	//也标记为已访问
	vis.add(p);