从大小为N的数组中选出第k小的数据

该博客介绍了如何从一个大小为N的数组中选择第k小的元素,通过一种类似于快速排序但不同于其平均时间复杂度为O(NlogN)的方法。算法采用递归策略,每次选取数组一部分并确定一个基准值,根据基准值划分数组,通过减少不必要的操作降低时间复杂度至O(N)。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

这个是从《编程珠玑(续)》的最后一章看到的,感觉相当的经典,特此mark一下。


话说一拿到这个题目直接想到的是快排之类的O(NlogN)复杂度的算法:即先排好序,再得到。时间复杂度O(NlogN)实际上是每一层的递归对N个数进行了操作,一共是logN层。下面介绍的算法类似于快排,但是和快排又有区别,每一层并不是操作了N个数,而是对其中的部分进行操作(感觉像是类似剪枝的过程),所以降低了时间复杂度。


算法概要:每一次递归对数组的部分(原始数组记为a,low表示此时部分数组的最小下标,high表示此时部分数组的最大下标)进行操作,第一次递归是整个数组。每一次递归都对数组的部分选定一个数(任意选,简单处理可以选第一个数a[low]),然后将a分为两部分,小于a[low]的和大于a[low]的,将a[low]作为边界放在两部分的中间,然后可以得到此时a[low]的下标index。若index==k,结束递归;若index<k,下一次迭代的范围是index+1到high;若index>k,下一次迭代的范围是low到index-1。


分析(平均)时间复杂度:N+N/2+N/4+N/8+......+1<2N,所以时间复杂度为O(N)。


public class Solution {
	
	//返回结果	k代表第k小的数		k从1开始
	public int solve(int[] list,int k){
		k = k-1;
		if( k>=0 && k<=list.length-1 )
			return subSolve(list,0,list.length-1,k);
		else
			return Integer.MIN_VALUE;
	}
	
	//返回查找的结果	i是当前的分界线,j是一直增长的
	public int subSolve(int[] list,int low,int high,int k){
			int i = low+1;
			for(in
<think>嗯,这个问题看起来有点挑战性。我需要仔细理解题目要求。题目是说,给定两个长度都为n的数组nums1和nums2,还有一个正整数k。对于每个位置i,我们需要找到所有满足nums1[j] < nums1[i]的j,然后在这些j对应的nums2[j]中选最多k个元素,使得它们的和最大。最后返回结果数组answer,其中answer[i]是这个最大的和。对吧? 首先,我得考虑如何处理每个i的情况。对于每个i来说,首先要找到所有j使得nums1[j] < nums1[i]。这一步可能需要先对nums1进行处理,比如排序,或者为每个i遍历整个数组来找符合条件的j。过这样时间复杂度可能很高,特别是当n很大的时候。 举个例子,假设nums1是[3,1,4,2],nums2是[5,6,7,8],k是2。对于i=0(nums1[i]=3),符合条件的j是那些nums1[j]<3的位置,也就是j=1和j=3。对应的nums2[j]是6和8。从中选最多2个,最大的和是6+8=14,所以answer[0]=14。 那如何高效地找到每个i对应的j呢?一个可能的方法是将nums1的元素进行排序,并记录它们的索引。比如,先对nums1进行排序,这样在处理每个i的时候,可以通过二分查找快速找到比当前nums1[i]小的所有元素的位置。这样可以将时间复杂度降低到O(n log n)的级别。 然后,对于每个i,找到对应的nums2[j]之后,需要从中选出最多k个最大的数,并求和。这部分可能需要将对应的nums2[j]进行排序,取前k个最大的数的和。例如,如果nums2[j]是[6,8],取前2个的和是14;如果k=1,则取最大的8,和为8。 那如何高效地处理这一步呢?可能需要为每个i预先存储其对应的nums2[j]列表,并按降序排列,然后计算前k项的前缀和。这样,当需要查询时,可以直接取前缀和数组中的最小值(k或者列表长度)。 举个例子,假设某个i对应的nums2[j]列表是[5,3,9,2],排序后降序是[9,5,3,2]。前缀和数组是[9, 14, 17, 19]。当k=2时,取前两项的和是14。当k大于列表长度时,取所有元素的和。 所以,可能的步骤是: 1. 预处理nums1和nums2,将每个元素按nums1的值进行排序,并记录对应的nums2的值。 2. 对于每个i,使用二分查找找到所有nums1[j] < nums1[i]的j,然后收集对应的nums2的值,并生成降序排列的前缀和数组。 3. 对于每个i,根据k的值,取前min(k, 列表长度)个元素的和,存入answer[i]。 但是,这样直接处理的话,时间复杂度可能很高,尤其是对于每个i都要做一次收集和排序。因为对于每个i,需要遍历所有j来找到符合条件的,这可能导致O(n^2)的时间复杂度,这在n很大的情况下可行。 那有没有更高效的方法呢?比如,能否在预处理的时候,对nums1进行排序,并为每个元素维护一个数据结构,可以快速查询比当前元素小的所有nums2的值,并且已经维护好降序排列的前缀和? 比如,可以先将所有nums1的元素和对应的nums2的值按照nums1的大小排序。然后,对于每个元素nums1[i],所有比它小的元素都在排序后的数组的前面部分。这样就可以在排序后的数组中,通过二分查找找到比当前nums1[i]小的最大的索引,然后取前面所有元素对应的nums2的值,再维护这些值的前缀和数组。 但这里有一个问题,排序后的数组可能打乱了原来的顺序,所以每个i对应的nums1[i]在排序后的位置是确定的。比如,排序后的数组是排序后的nums1和对应的nums2,比如sorted_pairs = sorted(zip(nums1, nums2))。然后,对于每个i,找到在sorted_pairs中nums1小于nums1[i]的元素,这可以通过二分查找找到最大的索引m,使得sorted_pairs[m][0] < nums1[i]。然后,前m+1个元素的nums2的值都是满足条件的。 这时候,可以维护一个结构,比如每个位置m对应的前m+1个元素的nums2的前缀和数组,其中已经降序排列。这样,当处理每个i时,找到对应的m后,就可以直接取该位置的前缀和数组中的前k项的和。 但如何维护这样的结构呢?比如,可以在排序后,按照nums1的顺序,逐步将元素加入到一个数据结构中,并在每一步记录当前已处理元素中的nums2的值的降序排列的前缀和。例如,当处理到排序后的第m个元素时,该元素以及之前的所有元素的nums1的值都小于等于当前元素的nums1值。但是,这可能需要动态维护一个有序的列表,并在插入新元素时保持降序排列,并计算前缀和。 或者,可以预处理所有可能的nums1的值,按照从小到大排序,并为每个元素存储对应的nums2的值。然后,对于每个排序后的元素,维护一个降序排列的nums2列表,以及对应的前缀和数组。这样,当处理原数组中的每个i时,找到所有在排序后的数组中比它小的元素的位置,然后合并这些元素的nums2列表,取最大的k个的和。 这似乎有些复杂,可能需要更深入的思考。 例如,假设sorted_pairs是按nums1从小到大排序的数组。对于每个元素sorted_pairs[m],它之前的元素(索引0到m-1)的nums1的值都比它小。因此,可以维护一个数据结构,在遍历sorted_pairs时,将每个元素的nums2的值加入到一个降序排列的列表,并维护前缀和数组。这样,对于每个sorted_pairs[m],当处理到它时,该列表包含所有nums1值比它小的元素的nums2的值,并且已经排序,前缀和数组也已经计算好。但是这样可能无法直接对应到原数组中的每个i的位置,因为原数组中的i可能对应到sorted_pairs中的某个位置m,而这时候前面的元素都是比sorted_pairs[m]小的。 但原问题中的i对应的nums1[i]可能有重复的情况,所以在排序后的数组中可能存在多个相同值的元素。这时候,需要处理所有严格小于nums1[i]的元素包括等于的情况。因此,对于原数组中的i,nums1[i]对应的所有j必须满足nums1[j] < nums1[i]。在排序后的数组中,可以使用bisect_left或bisect_right来找到对应的位置。 比如,假设sorted_nums1是按升序排列的数组,每个元素对应一个索引。对于原数组中的i,nums1[i]的值是x,那么使用bisect_left找到x的位置pos,所有在0到pos-1的位置对应的nums1的值都小于x。因此,这些元素的nums2的值都是候选。 然后,这些候选的nums2的值需要被收集起来,降序排列,并计算前缀和。这样,当处理原数组中的每个i时,找到对应的所有j的nums2的值,排序后取前k个的和。 但是,如何高效地为每个i找到这些nums2的值,并快速得到前k个的和呢? 这里的关键是预处理,将每个可能的x(nums1的值)对应的所有nums2的值存储起来,并按照降序排列,并计算前缀和数组。这样,当给定一个x时,可以快速找到所有比x小的元素的nums2的值的前k个之和。 具体步骤可能如下: 1. 将所有nums1的元素和对应的nums2的元素组成对,并按nums1的值进行升序排序。例如,sorted_pairs = sorted(zip(nums1, nums2), key=lambda x: x[0])。 2. 预处理每个位置m,在sorted_pairs中,前m+1个元素的nums1的值都小于等于sorted_pairs[m][0]。但我们需要的是严格小于的情况。所以对于原数组中的i,对应的x = nums1[i],需要找到在sorted_pairs中所有元素的nums1值严格小于x的元素的nums2的值。因此,可以使用bisect_left找到x的插入位置pos,所有0到pos-1的位置的元素的nums1值都小于x。 3. 对于这些pos-1个元素(假设pos>0),我们需要将这些元素的nums2的值取出来,降序排列,然后计算前缀和数组。例如,将这些nums2的值存入一个列表,排序后降序,然后计算前缀和数组sums,其中sums[i]是前i个元素的和。 4. 对于每个i,当找到对应的pos之后,取出这些nums2的值,然后取前k个的和。例如,如果列表长度为m,则取前min(k, m)个的和,即sums[min(k, m)-1]。 但是,问题在于如何高效地维护这些前缀和数组。因为对于同的x,对应的pos同,所以可能需要动态处理。 另一种思路是,维护一个数据结构,比如一个有序列表,随着x的增加,逐步将元素加入,并维护它们的降序排列的前缀和。例如,在遍历排序后的sorted_pairs时,每次处理一个元素,将它的nums2的值插入到一个数据结构中,并且保持该结构中的元素是降序排列的。同时,维护前缀和数组。这样,当处理到某个元素x时,所有已经处理过的元素的nums1的值都小于等于x的值。但这样是否可行? 例如,假设我们按nums1从小到大处理每个元素。对于每个元素x,当处理它时,所有之前的元素的nums1值都小于等于x。所以,当原数组中的某个i的nums1[i]等于x时,这些之前的元素的nums1的值可能等于x,这样会被选中(因为要求j的nums1[j] < nums1[i])。所以,这可能需要将元素按严格升序的方式处理,或者在处理时考虑严格小于的情况。 这似乎比较复杂。或许,更高效的方式是,将sorted_pairs按nums1升序排序,然后对于每个元素x,将所有nums1 < x的元素的nums2收集起来,排序后降序,然后计算前缀和。这样,对于每个i,只需要在sorted_pairs中找到所有严格小于x的元素的nums2,然后处理即可。 但是,这样每个i都需要进行一次这样的操作,时间复杂度是O(n log n + n * (m + log m)),其中m是符合条件的元素的数量。如果每个i的m接近n,那么总的时间复杂度是O(n^2),这在n很大的情况下是可接受的。例如,当n是1e5时,这样的时间复杂度会很高。 但是根据问题描述,题目中的n可能有多大呢?比如,在引用中的问题,例如引用[2]提到数组长度可以达到16。所以可能这个问题的n比较小,允许O(n^2)的时间复杂度? 假设题目中的n较小,那么可以采用以下步骤: 对于每个i: 1. 遍历所有j,找到满足nums1[j] < nums1[i]的j的集合。 2. 收集这些j对应的nums2[j]的值,组成列表。 3. 将列表排序,降序排列。 4. 计算前缀和数组,sums[0] = list[0], sums[1] = list[0] + list[1], 等等。 5. 如果列表的长度是m,那么answer[i] = sum前min(k, m)个元素的和,即sums[min(k, m)-1](如果列表为空的话,否则0)。 这样处理的时间复杂度是O(n^2 + n * m log m),其中m是平均每个i对应的j的数量。当n是1e4时,这样的复杂度可能无法通过,但如果n较小(比如n=1e3),则可以接受。 但根据引用中的例子,比如引用[2]中的数组长度最多是16,所以可能这个问题的n可能比较小,允许这样的暴力方法。 所以,可能的解决方案如下: 实现步骤: 1. 预处理每个i对应的符合条件的j的列表。 2. 对每个i的列表中的nums2[j]进行降序排序,并计算前缀和。 3. 取前k个的和。 具体代码实现: 比如用Python的话: answer = [] for i in range(n): current = nums1[i] candidates = [] for j in range(n): if nums1[j] < current: candidates.append(nums2[j]) # 降序排序 candidates.sort(reverse=True) # 计算前缀和 prefix = [0] for num in candidates: prefix.append(prefix[-1] + num) # 取前k个的和 max_sum = prefix[-1] if len(candidates) <=k else prefix[k] answer.append(max_sum if candidates else 0) return answer 但这样处理的时间复杂度是O(n^2) + O(n * m log m),其中m是每个i对应的候选数量。对于n=1e4,这可能需要1e8次操作,可能无法通过时间限制。但如果是n=1e3,那么是1e6次操作,可能可以接受。 那么,是否有更高效的方法? 这里,可以优化的点在于如何快速找到每个i对应的j的候选,并且如何快速得到他们的前k大元素的和。 针对每个i,需要找到所有nums1[j] < nums1[i]的j。这一步可以通过预处理nums1数组,将其排序,并为每个元素记录对应的nums2的值,并维护一个结构来快速查询前k大元素的和。 例如,可以将所有元素按nums1的值排序,然后对于每个元素,维护一个最大堆或者有序数组,记录所有比当前元素小的nums2的值,并维护前缀和数组。 具体来说: 步骤: 1. 将nums1和nums2合并为数组pairs = list of (nums1[i], nums2[i]),并按nums1从小到大排序。 2. 维护一个数据结构,用于保存当前已经处理过的元素的nums2的值,并且支持快速插入、排序以及计算前k大的和。例如,可以用一个降序排列的列表,并维护前缀和数组。 3. 遍历排序后的pairs数组,对于每个元素(x, y),此时所有已经处理过的元素的x都小于等于当前的x。但我们需要的是严格小于的情况。因此,在遍历时,我们需要将当前元素处理之前,已经处理过的元素的x严格小于当前的x的元素,才能被包含到当前元素的候选集中。 这可能需要处理重复的x值。例如,当存在多个相同的x值时,如何处理? 这里可能需要将排序后的数组分组,同一x值的元素一起处理。或者在遍历时,当处理到某个x时,将所有x值严格小于当前x的元素的nums2值收集到数据结构中,然后处理当前x对应的所有元素。 例如: 排序后的数组是按x升序排列的。遍历时,维护一个指针left,表示当前已经处理到的最大的x小于当前x的位置。这样,对于每个i,当处理到当前的x时,所有在left之前的元素的x都严格小于当前x。 这可能需要分组处理。例如,将排序后的数组分成同的组,每个组内的x相同。例如,遍历时,当x发生变化时,处理前一组的元素,并将它们的nums2值加入数据结构。 或者,遍历时,记录每个x出现的起始和结束位置。例如,先对排序后的数组进行分组,得到每个x的起始和结束索引。这样,当处理某个x时,所有比它小的x对应的组已经被处理,并加入到数据结构中。 这可能比较复杂。 另一种方法是,在遍历排序后的数组时,维护一个列表sorted_nums2,保存所有已处理的元素的nums2的值,并且保持降序排列,同时维护前缀和数组。这样,当处理到当前元素(x, y)时,所有已处理的元素的x都严格小于x的元素已经被加入到sorted_nums2中。因为排序后的数组是按x升序排列的,所以当处理到当前的x时,所有之前的元素的x可能小于等于当前x。因此,当处理到相同的x值时,需要将这些元素暂时加入sorted_nums2,直到遇到更大的x值时,再统一处理。 比如,维护一个临时列表temp,用于暂存相同x值的元素。当遍历到下一个更大的x时,将temp中的所有元素的nums2值加入sorted_nums2,排序并更新前缀和数组。然后处理当前的x对应的所有i,此时所有严格小于x的元素的nums2值已经被处理到sorted_nums2中。 这样,每个原数组中的i对应的x=nums1[i],当在排序后的数组中找到其对应的位置时,可以确保sorted_nums2中保存的是所有x严格小于当前x的元素的nums2值。这样,对于每个原数组中的i,找到在排序后的数组中比它小的元素的总数,然后取前k个的和。 这种方法的时间复杂度可能较低,因为预处理是按排序后的顺序进行的,并且每个元素只被处理一次。 具体步骤如下: 1. 将原数组的pairs按nums1升序排序,得到sorted_pairs。 2. 初始化一个空的列表sorted_nums2,并维护其降序排列的前缀和数组prefix_sums。 3. 遍历sorted_pairs,同时维护当前处理的x的值。每当x增大时,将之前暂存的相同x值的元素的nums2值插入到sorted_nums2中,排序并更新prefix_sums。 4. 对于原数组中的每个i,找到其对应的x=nums1[i],在sorted_pairs中找到所有严格小于x的元素的nums2值,这些值已经被处理到sorted_nums2中。然后取前k个的和。 但这里的问题是,如何将原数组中的i映射到sorted_pairs中的x的处理。因为原数组中的i对应的x可能分布在sorted_pairs的任何位置,所以需要为每个原数组的i,在预处理后的结构中快速找到对应的prefix_sums。 或者,可以预处理每个可能的x值对应的prefix_sums,然后在原数组处理时,直接查询对应的x值的prefix_sums。 比如,在预处理阶段,按x从小到大处理,每当遇到一个新的x值时,将之前所有比它小的x值的nums2值合并到sorted_nums2中,并维护prefix_sums。这样,每个x值对应一个prefix_sums数组,保存所有比它小的元素的nums2的前k大的和。 例如,可以维护一个字典,其中键是x值,值是该x对应的prefix_sums数组。当处理到某个x时,所有比它小的x值的元素已经被合并,并计算了prefix_sums。这样,当原数组中的i对应的x是某个值时,直接查询字典中该x对应的prefix_sums数组。 但这种方法可能难以处理所有可能的x值,特别是当x值很多时。 综上,可能最直接的方式是,对于每个i,遍历所有j,收集满足nums1[j]<nums1[i]的nums2[j],排序后取前k大的和。这在n较小的情况下是可行的。 例如,在Python中,可以用以下代码: def solution(nums1, nums2, k): n = len(nums1) answer = [] for i in range(n): current = nums1[i] candidates = [nums2[j] for j in range(n) if nums1[j] < current] candidates.sort(reverse=True) total = 0 for j in range(min(k, len(candidates))): total += candidates[j] answer.append(total) return answer 这将正确生成answer数组。例如,当nums1=[3,1,4,2], nums2=[5,6,7,8],k=2时: 对于i=0,nums1[i]=3,j符合条件的j是1(nums1[1]=1)和3(nums1[3]=2)。对应的nums2[j]是6和8。排序后是8,6。总和是8+6=14。所以answer[0]=14。 i=1,nums1[i]=1,没有j满足nums1[j]<1,所以总和为0. i=2,nums1[i]=4,符合条件的j是0,1,3。对应的nums2是5,6,8。排序后是8,6,5。取前2个,总和8+6=14. i=3,nums1[i]=2,符合条件的j是1(nums1[j]=1),对应的nums2[j]=6。总和是6. 所以answer=[14,0,14,6]。 这似乎正确。 但时间复杂度是O(n^2 + n * m log m),其中m是每个i对应的候选数量。对于n=1e4,这会非常慢。但如果n较小,比如n=1e3,那么时间复杂度是约1e6次操作,可以接受。 但是根据引用中的问题,例如引用[2]中的数组长度最多是16,所以可能这个问题的n比较小,允许这种暴力解法。 所以,这可能就是正确的解决方案。但需要处理一些边界情况,比如当没有符合条件的j时,answer[i]为0,或者当k为0时(但题目中k是正整数)。 另外,题目中说明,每个i对应的j可以是所有满足条件的,并且选最多k个元素。所以当k=0时可能没有元素可选,但题目中的k是给定的正整数,所以无需处理k=0的情况。 综上,这样的方法应该可行,但需要确保正确性。</think>### 问题分析 给定两个长度均为$n$的整数数组`nums1`和`nums2`,以及正整数$k$。对于每个下标$i$,需要找到所有满足`nums1[j] < nums1[i]`的$j$,并从对应的`nums2[j]`中选择最多$k$个值,使它们的和最大。最终返回结果数组`answer`,其中`answer[i]`表示该最大和。 ### 解决思路 1. **遍历每个元素**:对于每个$i$,遍历数组`nums1`,找到所有满足`nums1[j] < nums1[i]`的$j$。 2. **收集候选值**:将满足条件的`nums2[j]`存入列表。 3. **排序与求和**:对候选列表降序排列,取前$k$个元素求和(若候选数量足$k$个,则取全部)。 4. **边界处理**:若无候选元素,则和为$0$。 ### 代码实现 ```python def max_sum_selection(nums1, nums2, k): n = len(nums1) answer = [] for i in range(n): current = nums1[i] candidates = [] for j in range(n): if nums1[j] < current: candidates.append(nums2[j]) candidates.sort(reverse=True) total = sum(candidates[:k]) if candidates else 0 answer.append(total) return answer ``` ### 示例说明 假设输入: ``` nums1 = [3, 1, 4, 2] nums2 = [5, 6, 7, 8] k = 2 ``` - 对于$i=0$(`nums1[0]=3`),满足条件的$j$为$1$和$3$,对应`nums2`值为$[6, 8]$,降序排列后取前$2$个和为$14$。 - 对于$i=1$(`nums1[1]=1`),无满足条件的$j$,和为$0$。 - 最终结果为`[14, 0, 14, 6]`。 ### 时间复杂度 - 外层循环遍历$n$次,内层遍历和排序的时间为$O(n + m \log m)$($m$为候选元素数量)。 - 总时间复杂度为$O(n^2 + n \cdot m \log m)$,适用于$n$较小的场景[^1][^2]。 ### 优化方向 若$n$较大,可通过以下方法优化: 1. **预处理排序**:将`nums1`与索引一起排序,利用二分查找快速定位符合条件的$j$。 2. **前缀和数组**:维护降序排列的前缀和数组,避免重复排序和求和[^3]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值