未排序数组中累加和为给定值的最长子数组

本文详细解析了三种子数组求和问题的算法解决方案,包括仅正数数组的滑动窗口法,混合数数组的前缀和字典法,以及正负数平衡的子数组长度求解。每种方法均提供了代码实现,旨在帮助读者理解和掌握子数组求和问题的高效解决策略。

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

1.题目描述

给定一个数组arr,该数组无序,但每个值均为正数,再给定一个正数k。求arr的所有子数组中所有元素相加和为k的最长子数组的长度

例如,arr = [1, 2, 1, 1, 1], k = 3

累加和为3的最长子数组为[1, 1, 1],所以结果返回3

[要求]

时间复杂度为O(n)O(n),空间复杂度为O(1)O(1)

输入描述

第一行两个整数N, k。N表示数组长度,k的定义已在题目描述中给出
第二行N个整数表示数组内的数

输出描述

输出一个整数表示答案

解题思路

给定一个正数数组,求其子数组,可以使用两个指针left,right指向开始位置0,则初始化子数组的和sum为 arr[0],长度为right-left+1。

如果sum==k,则left和right确定的子数组符合要求,判断其长度,存储长度最大的值。

如果 sum<k,则right指针移动(因为数组中只有正数),如果sum>k,则指针left移动。移动时注意:right指针移动,是先right++,再sum+=arr[right];left指针移动,是先sum -=arr[left],再left ++。

N,k = list(map(int,input().split()))
arr = list(map(int,input().split()))

len_ = 0
sum_ = arr[0]
left,right = 0,0
while right<N:
    if sum_ == k:
        len_ = max(len_,right-left+1)
        sum_ -= arr[left]
        left += 1
    elif sum_ < k:
        right += 1
        if right >= N:
            break
        sum_ += arr[right]
    else:
        sum_ -= arr[left]
        left += 1
print(len_)

2.题目描述

给定一个无序数组arr, 其中元素可正、可负、可0。给定一个整数k,求arr所有子数组中累加和为k的最长子数组长度。

解题思路

当数组中同时存在正负数时,无法使用滑动的方法查找值为k的子数组,此时,应该换一种思路,用两个子数组相减的值来判断。

当我们遍历到i位置时,如果arr[0...i]-arr[0...j] == k,则说明arr[j...i] ==k。我们可以使用字典来记录arr[0...i]的值(重复出现的值记录最早出现的位置),就可以通过一次遍历得出结果。

代码实现

N,k = list(map(int,input().split()))
arr = list(map(int,input().split()))

len_ = 0
sub_dict = {}
sub_dict[0] = -1
sum_ = 0
for i in range(N):
    sum_ += arr[i]
    if sum_-k in sub_dict:
        len_ = max(len_,i-sub_dict[sum_-k])
    if sum_ in sub_dict:
        pass
    else:
        sub_dict[sum_] = i
print(len_)

3.题目描述

未排序数组中累加和为给定值的最长子数组系列问题补充1

给定一个无序数组arr,其中元素可正、可负、可0。求arr所有子数组中正数与负数个数相等的最长子数组的长度。

[要求]

时间复杂度为O(n)O(n),空间复杂度为O(n)O(n)

解题思路:

该题目为上一题的变形,使用count表示前i位中正负数的个数,正数count++,负数count--,0不变,思路和上一题相同。

N = int(input())
arr = list(map(int,input().split()))

len_ = 0
count = 0
sub_dict = {}
sub_dict[0] = -1

for i in range(N):
    if arr[i] > 0:
        count += 1
    elif arr[i] <0:
        count -= 1
    else:
        pass
    if count in sub_dict:
        len_ = max(len_,i-sub_dict[count])
    if count not in sub_dict:
        sub_dict[count] = i
print(len_)
    

 

<think>嗯,用户想用C++和树状数组实现长不降子序列的算法。首先,我得回忆一下长不降子序列(LIS)的常规解法。通常有两种方法,一种是动态规划O(n²),另一种是贪心加二分O(n log n)。但是用户提到要用树状数组,所以可能需要结合离散化和树状数组优化。 首先,树状数组常用于处理前缀和、区间查询等问题。而LIS问题中,我们需要维护一个数组,记录以每个元素结尾的长子序列长度。如果用树状数组的话,可能需要将元素的值离散化,因为原始数值可能很大,不适合直接作为索引。 那具体步骤应该是怎样的呢?比如,处理输入数组,将其离散化,然后遍历每个元素,查询当前元素在离散化后的位置对应的大值,然后更新树状数组。这样,每次查询和更新都是O(log n)的时间复杂度,整体复杂度应该能降到O(n log n)。 然后,离散化的过程需要注意重复元素的问题,因为长不降子序列允许非降序,所以离散化时要保留原始的顺序,可能需要稳定排序或者处理相同值时保持原序。 接下来,树状数组的设计。通常树状数组用于和,但这里需要维护的是大值。所以需要将树状数组的更新和查询操作改为取大值。也就是说,每个节点存储的是该区间内的大值,而不是和。 然后,具体实现的时候,遍历数组中的每个元素,找到其在离散化后的排名,查询树状数组中排名-1的位置的大值,加上1就是当前元素的长序列长度。然后更新树状数组在该排名处的值。 需要确认离散化是否正确处理了相等的情况,比如相等的元素应该被映射到相邻的排名,或者在查询时允许等于的情况。比如,在查询时,应该查询小于等于当前值的长度,这样在更新的时候才能正确累积。 可能还需要考虑是否需要稳定排序,或者在离散化时处理相同值的顺序。比如,使用排序后的数组去重,但保留原始的顺序,这样每个元素可以映射到对应的排名。 然后,具体的C++代码实现。需要包括离散化的步骤,树状数组的结构,以及主函数中的处理逻辑。例如,使用vector保存原始数组排序并去重得到离散化后的索引,然后使用lower_bound或upper_bound来获取每个元素的排名。注意这里如果是非降序,可能需要使用upper_bound来允许相等的元素。 此外,树状数组的更新和查询操作需要调整为处理大值。比如,update函数在更新时比较并取大值,而不是累加。query函数则是查询前缀中的大值。 后,测试一下这个算法是否正确。例如,给定一个测试用例,比如输入数组是{3, 1, 4, 1, 5, 9, 2, 6},离散化后的排名应该是处理后的索引,然后逐步计算每个位置的长度,并更新树状数组终得到的长不降子序列长度是否正确。 可能遇到的问题包括离散化错误导致索引越界,或者树状数组的更新逻辑不正确,比如没有正确处理大值,而是和导致结果错误。这时候需要仔细检查树状数组的update和query函数。 另外,注意树状数组的大小应该等于离散化后的大值加1,以避免索引超出范围。比如离散化后的元素范围是1到m,那么树状数组的大小应该是m+1。 总结一下,步骤应该是: 1. 离散化原数组,将元素映射到排名。 2. 初始化树状数组,用于维护大值。 3. 遍历原数组每个元素,找到其离散化后的排名。 4. 查询树状数组中1到该排名的大值,加1作为当前元素的长度。 5. 更新树状数组在该排名处的值为这个新长度。 6. 终,树状数组中的大值即为LIS的长度。 这样应该就能用树状数组在O(n log n)的时间复杂度内解决问题了。</think>### 使用C++和树状数组实现长不降子序列算法 #### 算法思路 长不降子序列(Longest Non-Decreasing Subsequence, LNDS)的树状数组解法基于以下步骤: 1. **离散化**:将原序列元素映射为压缩后的排名,解决值域过大问题[^3] 2. **树状数组维护大值**:树状数组每个节点存储对应区间内的大LNDS长度 3. **动态更新**:遍历元素时查询小于等于当前值的长度,并更新树状数组 #### 实现步骤 1. **离散化处理** ```cpp vector<int> discretization(vector<int>& nums) { vector<int> sorted(nums); sort(sorted.begin(), sorted.end()); sorted.erase(unique(sorted.begin(), sorted.end()), sorted.end()); for (int& num : nums) num = lower_bound(sorted.begin(), sorted.end(), num) - sorted.begin() + 1; return sorted; } ``` 2. **树状数组类(大值版本)** ```cpp class FenwickTree { private: vector<int> tree; public: FenwickTree(int size) : tree(size + 1, 0) {} void update(int idx, int value) { while (idx < tree.size()) { tree[idx] = max(tree[idx], value); idx += idx & -idx; } } int query(int idx) { int res = 0; while (idx > 0) { res = max(res, tree[idx]); idx -= idx & -idx; } return res; } }; ``` 3. **主算法实现** ```cpp int lengthOfLNDS(vector<int>& nums) { if (nums.empty()) return 0; discretization(nums); int maxRank = *max_element(nums.begin(), nums.end()); FenwickTree ft(maxRank); int res = 0; for (int num : nums) { int current = ft.query(num) + 1; res = max(res, current); ft.update(num, current); } return res; } ``` #### 算法分析 - **时间复杂度**:$O(n \log n)$,包含离散化$O(n \log n)$和树状数组操作$O(n \log n)$ - **空间复杂度**:$O(n)$,树状数组大小与离散化后的值域相关[^1] - **优化点**:通过离散化压缩值域,利用树状数组高效维护区间大值 #### 测试样例 输入:`[3, 1, 4, 1, 5, 9, 2, 6]` 离散化后排名:`[3, 1, 4, 1, 5, 6, 2, 7]` 输出:4(长序列如`[1, 4, 5, 6]`)
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值