1.子数组的取值范围

本文探讨了一种高效算法,用于查找数组中所有连续子数组,这些子数组的最大值与最小值之差超过指定阈值。该算法的时间复杂度为O(n),适用于大数据集的快速处理。

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

Description

给定数组arr和整数num,求arr的连续子数组中满足:其最大值减去最小值的结果大于num的个数。请实现一个时间复杂度为O(length(arr))的算法。

Input

输入的第一行为数组,每一个数用空格隔开,第二行为num

Output

输出一个值。

Sample Input 1 

3 6 4 3 2

2

Sample Output 1

6

def compare(numList,number):
    if(len(numList)==1):
        # print(len(numList))
        # print("false")
        return "false"
    else:
        max = numList[0]
        min = numList[0]
        for n in numList:
            if (n > max):
                max = n
            if (n < min):
                min = n
        if (max - min > number):
            return "true"
        else:

            return "false"
if __name__ == "__main__":
   arr = input()
   numList = [int(n) for n in arr.split()]
   number = input()
   number = int(number)
   count = 0
   lenth = len(numList)
   for i in range(lenth):
     for j in range(i,lenth):
        temp = compare(numList[i:j+1],number)
        if(temp == "true"):
              count = count + 1
   print(count)
c++做 代码 测试用例 测试结果 测试结果 Q1. 找出最大的几近缺失整 简单 3 分 给你一个数组 nums 一个 k 。 如果整 x 恰好仅出现在 nums 中的一个大小为 k 的子数组中,则认为 x 是 nums 中的几近缺失(almost missing)整。 返回 nums 中 最大的几近缺失 整,如果不存在这样的整,返回 -1子数组数组中的一个连续元素序列。 示例 1: 输入:nums = [3,9,2,1,7], k = 3 输出:7 解释: 1 出现在两个大小为 3 的子数组中:[9, 2, 1]、[2, 1, 7] 2 出现在三个大小为 3 的子数组中:[3, 9, 2]、[9, 2, 1]、[2, 1, 7] 3 出现在一个大小为 3 的子数组中:[3, 9, 2] 7 出现在一个大小为 3 的子数组中:[2, 1, 7] 9 出现在两个大小为 3 的子数组中:[3, 9, 2]、[9, 2, 1] 返回 7 ,因为它满足题意的所有整中最大的那个。 示例 2: 输入:nums = [3,9,7,2,1,7], k = 4 输出:3 解释: 1 出现在两个大小为 3 的子数组中:[9, 7, 2, 1]、[7, 2, 1, 7] 2 出现在三个大小为 3 的子数组中:[3, 9, 7, 2]、[9, 7, 2, 1]、[7, 2, 1, 7] 3 出现在一个大小为 3 的子数组中:[3, 9, 7, 2] 7 出现在三个大小为 3 的子数组中:[3, 9, 7, 2]、[9, 7, 2, 1]、[7, 2, 1, 7] 9 出现在两个大小为 3 的子数组中:[3, 9, 7, 2]、[9, 7, 2, 1] 返回 3 ,因为它满足题意的所有整中最大的那个。 示例 3: 输入:nums = [0,0], k = 1 输出:-1 解释: 不存在满足题意的整。 提示: 1 <= nums.length <= 50 0 <= nums[i] <= 50 1 <= k <= nums.length © 2025 领扣网络(上
03-11
<think>嗯,这个问题看起来有点挑战性。让我仔细读题目。题目是说,给定一个数组nums一个k,要找出最大的几近缺失整。所谓几近缺失整,是指这个x恰好只出现在一个长度为k的子数组里。如果没有这样的,就返回-1。那我得先理解清楚条件。 首先,子数组是连续的,所以每个长度为k的子数组都是连续的k个元素。然后,对于某个x来说,它必须恰好出现在其中一个这样的子数组中,并且不能出现在其他任何长度为k的子数组中。那也就是说,x出现的所有位置必须被包含在且仅在一个k长度的子数组里面。或者说,x的所有出现的位置都必须被某个特定的k长度子数组覆盖,并且不存在其他k长度的子数组包含x的其他出现位置? 或者可能题目中的条件更严格:x在整个数组中出现的时候,恰好只在某个k长度的子数组中出现一次,而在其他任何k长度的子数组中都不出现。比如说,如果x在某个k长度的子数组中出现过,但在其他k长度的子数组中也出现过,那么x就不是几近缺失的。 比如示例1中的输入nums = [3,9,2,1,7], k=3。对于字7来说,它出现在子数组[2,1,7]中,也就是最后一个子数组。而7在nums中只出现一次,所以这个子数组包含它,其他k长度的子数组没有包含它,所以7符合条件。而字3出现在第一个子数组[3,9,2]中,其他子数组可能没有3,所以3也符合条件。但为什么示例1的输出是7而不是3?因为要取最大的那个。 那问题转化为,我们需要统计每个x,在所有的k长度子数组中,出现的次。如果某个x在所有k长度子数组中出现的次1,那么它就是符合条件的候选,然后取最大的那个。 或者,更准确地说,x必须恰好出现在某一个k长度的子数组中,并且在整个数组中,x的所有出现的位置都被包含在该子数组中。或者说,不管x是否出现在多个k长度的子数组中,只要它出现在恰好一个k长度的子数组里,不管这个子数组中有多少个x的实例? 比如,假设k=3,有一个子数组是[2,2,3],其中x=2出现了两次。那么这个子数组包含x,所以对于这个子数组来说,x出现的次是多次。但不管子数组内部有多少个x,只要这个子数组存在,并且x在整个数组中的出现是否被其他子数组包含? 这时候可能需要明确题目中的条件。题目中的定义是:“恰好仅出现在nums中的一个大小为k的子数组中”。这里的“出现”指的是x存在于该子数组中,无论出现多少次。或者说,只要该子数组包含x一次或多次,就算作这个子数组出现了x。因此,如果一个子数组中有多个x,那么该子数组被算作包含x。这时候,x可能在多个子数组中出现。例如,假设数组是[2,2,2],k=2。那么子数组是[2,2](前两个元素)[2,2](后两个元素),所以每个子数组都包含x=2。那么x=2的出现次是两个子数组,所以不符合条件。 所以,判断条件应该是:x必须恰好出现在一个k长度的子数组中。也就是说,在所有可能的k长度的子数组中,只有一个子数组包含x,不管该子数组中x出现多少次。或者,x在整个数组中的所有出现的位置必须被包含在某个k长度的子数组中,并且不被其他任何k长度的子数组所包含。 比如,假设x在数组中的位置是ii+1,而k=3。如果有一个子数组从i-1到i+1,那么包含这两个x的位置。但另一个子数组可能从i到i+2,那么可能也包含这两个x的位置。这时候,x出现在多个子数组中,所以不满足条件。 因此,正确的条件应该是,x的所有出现的位置必须恰好被一个k长度的子数组覆盖。也就是说,x出现的所有位置必须全部位于某一个k长度的子数组范围内,并且没有其他k长度的子数组包含x的任何出现。 举个例,比如数组是[3,9,2,1,7],k=3。x=7的位置是索引4。唯一的k长度的子数组包含它的是子数组[2,1,7],即从索引2到4。所以x=7的所有出现(在这里只有一个)都被包含在这个子数组中,所以符合条件。而其他子数组是否包含7?其他子数组比如前面的几个,都不包含7,所以x=7符合条件。 另一个,比如nums=[3,9,7,2,1,7],k=4。其中一个子数组是[3,9,7,2],另一个是[9,7,2,1],第三个是[7,2,1,7]。x=3出现在第一个子数组,而其他子数组是否包含3?假设k=4,子数组的长度是4。nums的长度是6,所以子数组目是6-4+1=3。第一个子数组是0-3,包含3;第二个是1-4,不包含3;第三个是2-5,也不包含3。所以3只出现在第一个子数组中,所以符合条件。而最大的候选是3,所以输出3。 那如何判断x的所有出现的位置是否被恰好一个k长度的子数组覆盖? 可能的步骤: 1. 找出数组中所有存在的字x的可能候选。 2. 对于每个x,找出它在数组中的所有出现的位置(索引)。 3. 检查这些位置是否可以被某一个长度为k的子数组完全覆盖,并且不被其他任何长度为k的子数组覆盖。 或者更准确地说,是否存在一个长度为k的子数组,使得所有x的出现位置都在这个子数组范围内,并且不存在其他子数组范围内包含任何x的位置。 比如,假设x的所有出现的位置是i,j,k。那么必须存在一个子数组的起始索引s,使得 s <= i,j,k <= s +k -1。并且,对于其他任何子数组的起始索引s',其范围[s', s' +k-1]不能包含任何i,j,k中的位置。 或者,可能更简单的方式是,对于一个x的所有出现的位置,它们的索引必须全部位于某个唯一的子数组的区间内。例如,假设x的所有出现的位置的最小索引是min,最大索引是max。那么必须存在一个子数组的区间[start, start +k -1],其中start <= min,max <= start +k -1。并且,这个子数组是唯一的满足这个条件的子数组。换句话说,对于该x的所有出现的位置来说,它们的范围必须在某个子数组的区间内,并且不存在其他子数组的区间也包含所有这些位置中的至少一个。 或者,可能我的思路有问题。或许应该考虑,x的所有出现的位置必须全部被包含在某个子数组中,并且不存在其他任何子数组包含x的任何位置。这可能需要更严格的条件。 比如,x的所有出现的位置必须落在某个子数组范围内,并且这些位置不能落在其他任何子数组范围内。这样,这个子数组就是唯一的包含x的子数组。 那么,如何判断这一点? 举个例,假设x的出现的位置是索引23。k=3。那么可能的子数组长度是3。例如,子数组的起始索引0的区间是0-2,起始索引1的区间是1-3,起始索引2的区间是2-4(假设数组足够长)。假设数组长度是5,那么子数组的起始索引是0、1、2。那么,x的位置23会被哪些子数组覆盖? 起始索引0的子数组覆盖0-2,所以x的位置2会被包含。而起始索引1子数组覆盖1-3,所以位置23都被包含。起始索引2的子数组覆盖2-4,所以位置23都被包含。此时,x的位置同时被三个子数组覆盖。所以这种情况下,x的出现被多个子数组覆盖,所以不符合条件。 所以,如果x的出现的位置必须只能被一个子数组覆盖,那么我们需要找到所有x的位置的最小最大索引,然后找到是否存在一个子数组的区间[start, start +k -1] 包含所有这些位置,并且这个区间是唯一的包含这些位置的区间。 或者,可能更复杂的情况是,x的位置可能分布在不同的区间。比如,假设x的位置是0k。那么此时无法被一个子数组覆盖,因为子数组的长度为k,所以起始索引只能是0到n-k。例如,假设k=3,数组长度是5。起始索引可以是0、1、2。假设x的位置是03。则起始索引0的子数组包含0、1、2,不包含3。起始索引1子数组包含1、2、3。所以x的位置0不包含在起始索引1子数组中,而位置3被包含。所以这两个位置无法被同一个子数组覆盖。因此,这样的x的出现被多个子数组覆盖,不符合条件。 所以,判断条件是,x的所有出现的位置必须全部落在某一个子数组的区间内,并且对于所有其他子数组来说,它们的区间不包含x的任何位置。 那么如何计算呢? 步骤: 对于每个x,收集所有出现的位置的索引。 然后,检查这些位置是否可以被某个子数组的区间完全包含,并且这些位置不被任何其他子数组的区间包含。 例如,假设x的出现的位置是索引列表indices。 首先,找到这些indices的最小值min_idx最大值max_idx。 要满足这些indices被某个子数组的区间[start, start +k-1]包含,即: start <= min_idx <= max_idx <= start +k-1. 同时,该子数组的start必须满足 start <= min_idx,并且 start +k-1 >= max_idx. 然后,可能的start的范围是 max(0, max_idx -k +1) <= start <= min_idx. 或者,可能更直接的方式是,计算覆盖所有indices的最小区间的起始位置。例如,子数组必须覆盖从min_idx到max_idx的所有位置,并且长度至少为max_idx - min_idx +1。但子数组的长度是k,所以当max_idx - min_idx +1 >k时,无法被一个子数组覆盖,因此这样的x不可能满足条件。 例如,如果x的出现的位置的最小最大之间的距离超过k-1,则无法被任何k长度的子数组覆盖。此时,x不可能满足条件。例如,当x出现在索引0k的位置时,两者的距离是k,大于k-1。所以无法被一个k长度的子数组覆盖。此时,x的出现必须被多个子数组覆盖,或者无法被覆盖。因此这样的x不满足条件。 所以,首先,对于每个x,必须满足max_idx - min_idx +1 <=k。否则,无法被一个k长度的子数组覆盖。这种情况下,x的出现可能分布在多个子数组中,或者需要更大的子数组才能覆盖,但题目中k是固定的。所以这种情况,x不可能满足条件。 所以,第一步,对于每个x,计算其所有出现的位置的min_idxmax_idx。如果max_idx - min_idx +1 >k,则直接排除,无法满足条件。 否则,可能存在某些子数组可以覆盖所有这些位置。但是还需要确保,这些位置所在的唯一子数组区间。 例如,假设x的min_idx=2,max_idx=4,k=3。此时,覆盖这些位置的子数组的start可以是2(覆盖2-4),或者start=1(覆盖1-3),此时,x的位置4不在该子数组范围内。或者,假设k=3,那么子数组的start的取值范围是0到n-k。假设数组长度足够大。 所以,当max_idx - min_idx +1 <=k时,可能存在多个子数组覆盖这些位置吗? 比如,假设k=3,x的min_idx=2,max_idx=3。此时,可能的子数组的start可以是1(覆盖1-3),此时start=1子数组是[1,2,3],包含x的位置23。或者start=2,子数组是[2,3,4],也包含x的位置23。这时候,这两个不同的子数组都包含了x的位置。因此,x的出现会被这两个子数组覆盖,因此,x的出现次在两个子数组中,因此不符合条件。 所以,在这种情况下,虽然x的位置的跨度是2(3-2+1=2 <=k=3),但存在多个子数组覆盖这些位置,因此x的出现次超过一个子数组,所以x不满足条件。 所以,正确的条件是: 对于x来说,其所有出现的位置必须被某个唯一的子数组覆盖。也就是说,存在且仅存在一个start值,使得该子数组的区间[start, start +k-1]包含所有x的位置,并且其他任何子数组的区间都不包含x的任何位置。 这似乎比较难处理。或者,可以换一种思路:对于每个可能的子数组,统计该子数组中的元素,然后记录每个元素是否仅出现在该子数组中。但这种方法可能比较低效,因为子数组量是O(n),每个子数组的长度是k,总共有O(nk)的时间复杂度,但题目中n<=50,所以可行。 可能的算法步骤如下: 1. 对于每个可能的子数组(长度为k),记录该子数组中的元素集合。或者,记录每个元素是否出现在该子数组中。 或者,更准确地说,对于每个子数组,我们可以记录其中包含哪些元素。例如,子数组s的元素可能有重复,但不管出现次如何,只要元素存在于s中,就被视为该子数组包含该元素一次。 例如,子数组s中的元素可能有多个x,但不管目如何,只要x出现至少一次,就算该子数组包含x一次。 然后,我们需要统计每个元素x被包含在多少个子数组中。如果x被包含在恰好一个子数组中,那么x是候选之一。然后在所有候选x中取最大的那个。 例如,假设有一个子数组包含x,而其他子数组都不包含x,那么x符合条件。这时候x的最大出现次1次,出现在该子数组中。 这似乎是一个可行的思路。例如,在示例1中: nums = [3,9,2,1,7], k=3。子数组有: 0-2: [3,9,2] &rarr;包含3,9,2 1-3: [9,2,1] &rarr;包含9,2,1 2-4: [2,1,7] &rarr;包含2,1,7 然后,每个元素出现的子数组目: 3: 出现在子数组0-2 &rarr;次1 9: 出现在0-21-3 &rarr;次2 &rarr;不符合条件 2: 出现在三个子数组 &rarr;次3 &rarr;不符合 1: 出现在1-32-4 &rarr;次2 &rarr;不符合 7: 出现在2-4 &rarr;次1 &rarr;符合条件 其他元素比如,比如nums中没有0,所以不考虑。所以最大的符合条件的x是7。 这与示例1的输出吻合。 同样的示例2: 输入nums = [3,9,7,2,1,7],k=4。子数组的长度是4。总共有6-4+1=3个子数组: 0-3: [3,9,7,2] 1-4: [9,7,2,1] 2-5: [7,2,1,7] 每个子数组的元素: 第一个子数组包含3、9、7、2 &rarr;每个元素出现的次1。 第二个子数组包含9、7、2、1 &rarr;这些元素的次1. 第三个子数组包含7、2、1、7 &rarr;注意,7出现两次,但该子数组只算包含7一次? 或者,不管出现次,只要元素存在于子数组中,次就加1。 比如,第三个子数组中的7出现了两次,但该子数组中的元素7的存在次1次。即,每个子数组对每个元素的计贡献为1次,不管元素在该子数组中出现的次。 那么对于元素3来说,只出现在第一个子数组中,次1 &rarr;符合条件,最大候选是3。 其他元素如9出现在第一个第二个子数组中,次是2 &rarr;不符合条件。所以输出3。 这与示例2的输出吻合。 那问题的解法应该是: 统计每个元素x出现的子数组量。这里的出现次是指,如果该元素出现在某个子数组中至少一次,则计1。不管该子数组中该元素出现多少次,只要出现至少一次,就算一次。 然后,所有计等于1的x中最大的那个即为答案。如果没有这样的x,则返回-1。 哦,这样问题就变得简单了! 那算法步骤: 1. 遍历所有可能的长度为k的子数组。 2. 对于每个子数组,记录其中出现的所有元素(去重后的集合)。 3. 对于每个元素,统计它出现在多少个不同的子数组中。 4. 最后,遍历所有出现过的元素,找出那些出现次恰好为1的元素中的最大值。如果没有,则返回-1。 这似乎正确。那么示例3中的输入nums = [0,0],k=1子数组的长度是1,所以每个元素单独构成子数组。共有两个子数组:[0][0]。每个子数组中的元素都是0。所以0出现的次是2。因此没有符合条件的元素,返回-1,这与示例3的输出一致。 那这样,问题就转化为统计每个元素在多少个子数组中出现过,然后找到出现次恰好为1的最大元素。 那如何实现这个算法? 步骤: - 遍历数组中的每个可能的子数组(start从0到n-k)。 - 对于每个子数组,收集其中的元素的集合(去重)。 - 维护一个字典或者哈希表,记录每个元素出现的子数组目。 - 最后,遍历该字典,找出所有值为1的键中的最大值。 例如,在C++中,可以用一个unordered_map<int, int>来记录每个元素出现的次。 然后,对于每个子数组,遍历其中的元素,将元素存入一个集合(去重),然后遍历该集合中的元素,将对应的计器加1。 这样,每个子数组中的重复元素不会导致多次计,因为集合已经去重。 例如,子数组是[7,2,1,7],其中7出现两次。在集合中是{1,2,7}。所以每个元素在该子数组中被计一次。 这符合问题的要,因为只要元素出现在子数组中至少一次,就认为该子数组包含它,不管次。 因此,这个算法是正确的。 现在,我需要编写代码来实现这个逻辑。 代码步骤: 1. 首先检查nums的大小是否小于k?比如,当nums.size() <k时,无法形成任何子数组。但根据提示,k的取值范围1<=k<=nums.length。所以当nums.size() >=k时,才能形成子数组。所以对于输入nums的长度是n,子数组量是n -k +1。 例如,当nums.size() ==0时?但根据提示,nums的长度>=1。所以无需处理空数组的情况。 2. 初始化一个哈希表count,记录每个元素出现的次。 3. 遍历每个子数组的起始位置start,从0到n-k。 4. 对于每个start,对应的子数组nums[start ... start +k-1]. 5. 将该子数组中的元素存入一个集合,去重。 6. 遍历该集合中的每个元素x,将count[x]加1. 7. 所有子数组处理完成后,遍历count中的所有键,找到那些值等于1的键中的最大值。 8. 如果没有这样的键,返回-1. 这样,就可以得到正确的结果。 现在,测试示例: 示例1nums = [3,9,2,1,7],k=3. 子数组是: start=0: [3,9,2] &rarr;集合是{3,9,2} &rarr;各元素计+1. start=1: [9,2,1] &rarr;集合是{9,2,1} &rarr;各元素计+1. start=2: [2,1,7] &rarr;集合是{2,1,7} &rarr;各元素计+1. count: 3 &rarr;1 9 &rarr;2 2 &rarr;3 1 &rarr;2 7 &rarr;1 所以符合条件的元素是37,其中最大的7,正确。 示例2: nums = [3,9,7,2,1,7],k=4. 子数组有三个: start=0: [3,9,7,2] &rarr;集合是{3,9,7,2} start=1: [9,7,2,1] &rarr;集合是{9,7,2,1} start=2: [7,2,1,7] &rarr;集合是{7,2,1} (因为元素重复的7被去重) 所以各元素的计: 3: 1 &rarr;出现在start=0的子数组. 9: 2 &rarr;出现在start=0start=1. 7: 3 &rarr;出现在start=0, start=1, start=2的子数组. 2: 3 &rarr;出现在start=0,1,2. 1: 2 &rarr;出现在start=1,2. 所以,符合条件的元素只有3,返回3. 示例3: nums = [0,0],k=1. 子数组是start=0: [0],start=1: [0]. 每个子数组的集合是{0},所以0的计是2 &rarr;不符合条件。返回-1. 所以,这个算法是正确的。 现在,如何编写C++代码? 代码的大致结构: 函是: int findMaxAlmostMissing(vector<int>& nums, int k) { unordered_map<int, int> count; int n = nums.size(); for (int start =0; start <= n -k; start++) { unordered_set<int> unique; for (int i=start; i<start +k; i++) { unique.insert(nums[i]); } for (int x : unique) { count[x]++; } } int max_val = -1; for (auto& [num, cnt] : count) { if (cnt ==1) { if (num > max_val) { max_val = num; } } } return max_val; } 这样应该可以。 测试示例: 例如示例1的输入: nums = {3,9,2,1,7},k=3. 代码中的循环start从0到2(n=5, n-k=5-3=2)。 start=0时,unique是3,9,2 &rarr;它们的count分别加1. start=1时,unique是9,2,1 &rarr;它们的count分别加1. start=2时,unique是2,1,7 &rarr;它们的count分别加1. 最后,count中各个值的次: 3 &rarr;1 &rarr;符合条件. 9 &rarr;2. 2 &rarr;3. 1 &rarr;2. 7 &rarr;1. 所以最大的符合条件的是7. 正确。 另一个测试用例,比如nums = [3,9,7,2,1,7],k=4. n=6, k=4 &rarr;start可以是0,1,2. start=0:子数组0-3 &rarr;元素3,9,7,2 &rarr;unique集合是{3,9,7,2} &rarr;各加1. start=1:子数组1-4 &rarr;元素9,7,2,1 &rarr;unique是{9,7,2,1} &rarr;各加1. start=2:子数组2-5 &rarr;元素7,2,1,7 &rarr;去重后是{7,2,1} &rarr;各加1. 所以: 3的count是1 &rarr;符合条件. 9的count是2. 7的count是3. 2的count是3. 1的count是2. 所以最大的符合条件的是3. 正确。 所以这个代码应该可以解决问题。 现在,考虑边界情况: 比如nums的长度等于k,那么只有1子数组。此时所有在该子数组中出现的元素的计都是1。所以最大的元素是子数组中的最大值。 例如,nums = [5,4,3],k=3 &rarr;子数组是[5,4,3]。所有元素出现次1。所以最大的元素是5.一个情况,当k=1,每个元素自己成为一个子数组。此时,元素的计等于其在数组中出现的次。例如,nums=[2,3,2],k=1。每个子数组是[2], [3], [2]. 元素2出现两次,3出现一次。所以符合条件的元素是3。返回3. 但是如果nums中的元素有重复的,比如nums=[2,2,2],k=1。每个子数组一个元素,所以元素2出现三次。计为3,所以不满足条件,返回-1. 现在,代码是否能处理这些情况? 是的。因为当k=1时,每个元素单独作为子数组,此时每个元素的计等于其在数组中出现的次。只有当该元素仅出现一次时,其计1。例如,nums=[2,3,2],k=1 &rarr;元素2出现两次,计为2;3出现一次,计1 &rarr;所以返回3. 所以代码正确。 综上,该算法是正确的。</think>要解决这个问题,我们需要找到数组中最大的几近缺失整。几近缺失整定义为恰好出现在一个大小为k的子数组中的整。以下是详细的解决步骤: ### 方法思路 1. **遍历所有子数组**:生成所有长度为k的连续子数组。 2. **统计元素出现次**:使用哈希表记录每个元素在不同子数组中出现的次。每个子数组中的元素去重后统计,确保每个子数组对元素的计贡献一次。 3. **筛选结果**:遍历哈希表,找出出现次恰好为1的最大元素。若不存在则返回-1。 ### 解决代码 ```cpp #include <vector> #include <unordered_set> #include <unordered_map> using namespace std; int findMaxAlmostMissing(vector<int>& nums, int k) { unordered_map<int, int> count; int n = nums.size(); for (int start = 0; start <= n - k; ++start) { unordered_set<int> unique_elements; for (int i = start; i < start + k; ++i) { unique_elements.insert(nums[i]); } for (int x : unique_elements) { count[x]++; } } int max_val = -1; for (auto& [num, cnt] : count) { if (cnt == 1 && num > max_val) { max_val = num; } } return max_val; } ``` ### 代码解释 1. **哈希表初始化**:`unordered_map<int, int> count` 用于记录每个元素出现的子数组目。 2. **遍历子数组**:外层循环遍历所有可能的子数组起始位置`start`。 3. **去重处理**:内层循环将当前子数组元素存入集合`unique_elements`以去重。 4. **统计次**:遍历集合中的元素,更新哈希表中的计。 5. **筛选最大值**:遍历哈希表,找出出现次1的最大元素。 ### 测试用例与结果 **示例1**: - 输入:`nums = [3,9,2,1,7], k = 3` - 输出:`7` - 解释:7仅出现在子数组`[2,1,7]`中,是最大的符合条件的整。 **示例2**: - 输入:`nums = [3,9,7,2,1,7], k = 4` - 输出:`3` - 解释:3仅出现在子数组`[3,9,7,2]`中,是最大的符合条件的整。 **示例3**: - 输入:`nums = [0,0], k = 1` - 输出:`-1` - 解释:所有元素出现的子数组超过1,无符合条件整。 ### 复杂度分析 - **时间复杂度**:$O(n \cdot k)$,其中n为数组长度。遍历所有子数组的时间为$O(n)$,每个子数组处理时间为$O(k)$。 - **空间复杂度**:$O(n)$,哈希表集合最多存储n个不同元素。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值