K个最小和(K Smallest Sums)

K Smallest Sums

You're given k arrays, each array has k integers. There are kk ways to pick exactly one element in each array and calculate the sum of the integers. Your task is to find the k smallest sums among them.

Input

There will be several test cases. The first line of each case contains an integer k (2<=k<=750). Each of the following k lines contains k positive integers in each array. Each of these integers does not exceed 1,000,000. The input is terminated by end-of-file (EOF). The size of input file does not exceed 5MB.

Output

For each test case, print the k smallest sums, in ascending order.

Sample Input

3
1 8 5
9 2 5
10 7 6
2
1 1
1 2

Output for the Sample Input

9 10 12

2 2


分析:本题也是用优先级队列来解决多路归并问题。本题输入数据有多行,每次处理两行,然后从第一列开始处理,之后两两合并。

初步代码如下:

#include <cstdio>
#include <queue>
#include <algorithm>
using namespace std;
const int maxn = 768;
int A[maxn][maxn];
struct Node 
{
	int sum,b;
	Node(int s,int b) : sum(s) , b(b) {}
	bool operator<(const Node & obj) const
	{
		return sum > obj.sum;
	}
};
void merge(int *A,int *B,int *C,int n)
{
	priority_queue<Node> pq;
	for (int i = 0; i < n; i++)
		pq.push(Node(A[i] + B[0],0));
	for (int j = 0; j < n; j++)
	{
		Node item = pq.top();
		pq.pop();
		C[j] = item.sum;
		int b = item.b;
		if (b + 1 < n)
			pq.push(Node(item.sum - B[b] + B[b + 1], b + 1));//取下一个数
	}
}
int main()
{
	int n;
	while (scanf("%d",&n) == 1)
	{
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
				scanf("%d",&A[i][j]);
			sort(A[i],A[i] + n);
		}
		for (int k = 1; k < n; k++)//两两合并
			merge(A[0],A[k],A[0],n);
		printf("%d",A[0][0]);
		for (int j = 1; j < n; j++)
			printf(" %d",A[0][j]);
		printf("\n");
	}
	return 0;
}
仔细考虑下,会发现以上代码可以改进,其实一开始并不需要把K*K元素都保存。可以每次只读k个元素,这样大大降低了空间复杂度,改进后的代码如下:

#include <cstdio>
#include <queue>
#include <algorithm>
using namespace std;
const int maxn = 768;
int A[maxn],B[maxn];
struct Node 
{
	int sum,b;
	Node(int s,int b) : sum(s) , b(b) {}
	bool operator<(const Node & obj) const
	{
		return sum > obj.sum;
	}
};
void merge(int *A,int *B,int *C,int n)
{
	priority_queue<Node> pq;
	for (int i = 0; i < n; i++)
		pq.push(Node(A[i] + B[0],0));
	for (int j = 0; j < n; j++)
	{
		Node item = pq.top();
		pq.pop();
		C[j] = item.sum;
		int b = item.b;
		if (b + 1 < n)
			pq.push(Node(item.sum - B[b] + B[b + 1], b + 1));
	}
}
int main()
{
	int n;
	while (scanf("%d",&n) == 1)
	{
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)//每次读一行
				scanf("%d",&A[j]);
			sort(A,A + n);
			if (i != 0)
				merge(B,A,B,n);//两两合并
			else
				for (int k = 0; k < n; k++)
					B[k] = A[k];
		}
		printf("%d",B[0]);
		for (int j = 1; j < n; j++)
			printf(" %d",B[j]);
		printf("\n");
	}
	return 0;
}




在处理从 `n` 个数中找出最小的 `k` 个数的问题时,可以采用多种算法策略,具体选择取决于时间复杂度要求、空间限制以及数据规模。以下是几种常见的实现方法及其分析。 ### 方法一:排序后取前 k 个数 最直观的方法是对整个数组进行排序(如快速排序或堆排序),然后取前 `k` 个元素。这种方法的时间复杂度为 `O(n log n)`,适用于数据量较小的情况。 ```python def find_k_smallest_sort(nums, k): nums.sort() return nums[:k] ``` 该方法简单易实现,但排序所有元素可能并不高效,尤其当 `k` 远小于 `n` 时[^1]。 ### 方法二:使用最大堆(Max Heap) 为了优化性能,可以维护一个大小为 `k` 的最大堆。遍历数组中的每个元素: - 如果堆的大小小于 `k`,直接将元素加入堆。 - 否则,若当前元素小于堆顶元素,则弹出堆顶并插入当前元素。 最终堆中的元素即为最小的 `k` 个数。这种方法的时间复杂度约为 `O(n log k)`。 ```python import heapq def find_k_smallest_max_heap(nums, k): if k == 0: return [] # 使用负值构造最大堆 heap = [-x for x in nums[:k]] heapq.heapify(heap) for num in nums[k:]: if -num > heap[0]: heapq.heappop(heap) heapq.heappush(heap, -num) return [-x for x in heap] ``` 这种方法在实际应用中较为高效,尤其适合大数据集处理[^2]。 ### 方法三:基于快速选择(QuickSelect) 快速选择是一种基于快速排序的分治算法,可以在平均 `O(n)` 时间内找到第 `k` 小的元素。通过划分操作,可以将数组分为两部分,一部分小于等于基准值,另一部分大于基准值。递归地对包含最小 `k` 个元素的部分进行处理即可。 ```python def partition(arr, low, high): pivot = arr[high] i = low - 1 for j in range(low, high): if arr[j] <= pivot: i += 1 arr[i], arr[j] = arr[j], arr[i] arr[i + 1], arr[high] = arr[high], arr[i + 1] return i + 1 def quickselect(arr, low, high, k): while low <= high: pi = partition(arr, low, high) if pi == k - 1: return arr[:k] elif pi < k - 1: low = pi + 1 else: high = pi - 1 return arr[:k] def find_k_smallest_quickselect(nums, k): return quickselect(nums, 0, len(nums) - 1, k) ``` 该方法在理论上的平均时间复杂度为 `O(n)`,且不需要额外空间,适合内存受限的场景[^3]。 ### 方法四:使用优先队列(Priority Queue) Python 中的 `heapq` 模块提供了一个最小堆结构,可以直接用来获取最小的 `k` 个数。其核心思想是利用堆结构自动维护最小值。 ```python import heapq def find_k_smallest_priority_queue(nums, k): return heapq.nsmallest(k, nums) ``` 此方法内部实现与最大堆类似,但在 Python 中更简洁且性能良好[^2]。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值