专栏导读
本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。
一、题目描述
给定一个数列，我们称其中连续的元素为连续子序列，称这些元素的和为连续子序列的和。
数列中可能存在几个组连续子序列，组内的连续子序列互不相交且有相同的和。
求一组连续子序列，组内子序列的数目最多。
输出这个数目。
二、输入描述
第一行输入为 数组长度 N， 1 <= N <= 103
第二行为 N 个用空格分开的整数 Ci， -105 <= Ci <= 105
三、输出描述
第一行是一个整数 M，表示满足要求的最多的组内子序列的数目。
四、测试用例
测试用例1
1、输入
5
1 -1 1 -1 1
2、输出
3
3、说明
和为1的连续子序列最多，可以选择位置[0,0], [2,2], [4,4]三个不相交区间
测试用例2
1、输入
3
1 2 3
2、输出
2
3、说明
和为3的子序列有[3]和[1,2]，可以选择2个不相交区间
五、解题思路
- 枚举所有可能的连续子序列及其和值
- 将相同和值的子序列分组
- 对于每组，使用贪心算法求解最大不相交区间数量
- 返回所有组中的最大值
使用HashMap存储每个和值对应的所有区间
使用贪心算法解决区间调度问题：按结束位置排序，依次选择不相交的区间
六、Python算法源码
# 读取数组长度
n = int(input())
# 读取数组元素，并转换为整数列表
nums = list(map(int, input().split()))
# 使用字典存储每个和值对应的所有连续子序列区间
# key: 连续子序列的和, value: 对应区间列表 [起始位置, 结束位置]
sum_to_intervals = {}
# 枚举所有可能的连续子序列
for i in range(n):
current_sum = 0
for j in range(i, n):
current_sum += nums[j] # 累加得到从i到j的连续子序列和
# 将区间[i, j]添加到对应和值的列表中
if current_sum not in sum_to_intervals:
sum_to_intervals[current_sum] = []
sum_to_intervals[current_sum].append([i, j])
max_count = 0 # 记录最大的不相交区间数量
# 对于每个和值，计算最多能选择多少个互不相交的区间
for intervals in sum_to_intervals.values():
# 贪心算法：按照区间结束位置排序
intervals.sort(key=lambda x: x[1])
count = 0 # 当前和值对应的最大不相交区间数量
last_end = -1 # 上一个选择的区间的结束位置
# 遍历所有区间，贪心选择
for interval in intervals:
# 如果当前区间的起始位置大于上一个区间的结束位置，则可以选择
if interval[0] > last_end:
count += 1
last_end = interval[1] # 更新结束位置
# 更新全局最大值
max_count = max(max_count, count)
# 输出结果
print(max_count)
七、JavaScript算法源码
// 从标准输入读取数据
const readline = require('readline');
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
let lineCount = 0;
let n = 0;
let nums = [];
rl.on('line', (line) => {
if (lineCount === 0) {
// 读取数组长度
n = parseInt(line);
lineCount++;
} else {
// 读取数组元素，并转换为整数数组
nums = line.split(' ').map(Number);
rl.close();
}
});
rl.on('close', () => {
// 使用Map存储每个和值对应的所有连续子序列区间
// key: 连续子序列的和, value: 对应区间列表 [起始位置, 结束位置]
const sumToIntervals = new Map();
// 枚举所有可能的连续子序列
for (let i = 0; i < n; i++) {
let currentSum = 0;
for (let j = i; j < n; j++) {
currentSum += nums[j]; // 累加得到从i到j的连续子序列和
// 将区间[i, j]添加到对应和值的列表中
if (!sumToIntervals.has(currentSum)) {
sumToIntervals.set(currentSum, []);
}
sumToIntervals.get(currentSum).push([i, j]);
}
}
let maxCount = 0; // 记录最大的不相交区间数量
// 对于每个和值，计算最多能选择多少个互不相交的区间
for (const intervals of sumToIntervals.values()) {
// 贪心算法：按照区间结束位置排序
intervals.sort((a, b) => a[1] - b[1]);
let count = 0; // 当前和值对应的最大不相交区间数量
let lastEnd = -1; // 上一个选择的区间的结束位置
// 遍历所有区间，贪心选择
for (const interval of intervals) {
// 如果当前区间的起始位置大于上一个区间的结束位置，则可以选择
if (interval[0] > lastEnd) {
count++;
lastEnd = interval[1]; // 更新结束位置
}
}
// 更新全局最大值
maxCount = Math.max(maxCount, count);
}
// 输出结果
console.log(maxCount);
});
八、C算法源码
#include <stdio.h>
#include <stdlib.h>
// 定义区间结构体
typedef struct {
int start; // 区间起始位置
int end; // 区间结束位置
} Interval;
// 比较函数，用于按结束位置排序
int compare(const void *a, const void *b) {
Interval *ia = (Interval *)a;
Interval *ib = (Interval *)b;
return ia->end - ib->end;
}
int main() {
int n;
// 读取数组长度
scanf("%d", &n);
// 动态分配数组空间并读取数组元素
int *nums = (int *)malloc(n * sizeof(int));
for (int i = 0; i < n; i++) {
scanf("%d", &nums[i]);
}
// 由于C语言没有内置的HashMap，我们使用一个较大的数组来模拟
// 假设所有可能的和值在[-10^6, 10^6]范围内
const int MAX_SUM = 1000000;
const int OFFSET = MAX_SUM; // 偏移量，将负数索引转换为正数
// 为每个可能的和值分配区间数组
Interval **sum_intervals = (Interval **)calloc(2 * MAX_SUM + 1, sizeof(Interval *));
int *sum_counts = (int *)calloc(2 * MAX_SUM + 1, sizeof(int));
// 枚举所有可能的连续子序列
for (int i = 0; i < n; i++) {
int current_sum = 0;
for (int j = i; j < n; j++) {
current_sum += nums[j]; // 累加得到从i到j的连续子序列和
int index = current_sum + OFFSET; // 转换为数组索引
// 为该和值分配或扩展区间数组
if (sum_intervals[index] == NULL) {
sum_intervals[index] = (Interval *)malloc(n * n * sizeof(Interval));
}
// 添加新区间
sum_intervals[index][sum_counts[index]].start = i;
sum_intervals[index][sum_counts[index]].end = j;
sum_counts[index]++;
}
}
int max_count = 0; // 记录最大的不相交区间数量
// 对于每个和值，计算最多能选择多少个互不相交的区间
for (int i = 0; i < 2 * MAX_SUM + 1; i++) {
if (sum_counts[i] > 0) {
// 贪心算法：按照区间结束位置排序
qsort(sum_intervals[i], sum_counts[i], sizeof(Interval), compare);
int count = 0; // 当前和值对应的最大不相交区间数量
int last_end = -1; // 上一个选择的区间的结束位置
// 遍历所有区间，贪心选择
for (int j = 0; j < sum_counts[i]; j++) {
// 如果当前区间的起始位置大于上一个区间的结束位置，则可以选择
if (sum_intervals[i][j].start > last_end) {
count++;
last_end = sum_intervals[i][j].end; // 更新结束位置
}
}
// 更新全局最大值
if (count > max_count) {
max_count = count;
}
}
}
// 输出结果
printf("%d\n", max_count);
// 释放内存
for (int i = 0; i < 2 * MAX_SUM + 1; i++) {
if (sum_intervals[i] != NULL) {
free(sum_intervals[i]);
}
}
free(sum_intervals);
free(sum_counts);
free(nums);
return 0;
}
九、C++算法源码
#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
using namespace std;
int main() {
int n;
// 读取数组长度
cin >> n;
// 读取数组元素
vector<int> nums(n);
for (int i = 0; i < n; i++) {
cin >> nums[i];
}
// 使用unordered_map存储每个和值对应的所有连续子序列区间
// key: 连续子序列的和, value: 对应区间列表 pair<起始位置, 结束位置>
unordered_map<int, vector<pair<int, int>>> sumToIntervals;
// 枚举所有可能的连续子序列
for (int i = 0; i < n; i++) {
int currentSum = 0;
for (int j = i; j < n; j++) {
currentSum += nums[j]; // 累加得到从i到j的连续子序列和
// 将区间[i, j]添加到对应和值的列表中
sumToIntervals[currentSum].push_back({i, j});
}
}
int maxCount = 0; // 记录最大的不相交区间数量
// 对于每个和值，计算最多能选择多少个互不相交的区间
for (auto& entry : sumToIntervals) {
vector<pair<int, int>>& intervals = entry.second;
// 贪心算法：按照区间结束位置排序
sort(intervals.begin(), intervals.end(),
[](const pair<int, int>& a, const pair<int, int>& b) {
return a.second < b.second;
});
int count = 0; // 当前和值对应的最大不相交区间数量
int lastEnd = -1; // 上一个选择的区间的结束位置
// 遍历所有区间，贪心选择
for (const auto& interval : intervals) {
// 如果当前区间的起始位置大于上一个区间的结束位置，则可以选择
if (interval.first > lastEnd) {
count++;
lastEnd = interval.second; // 更新结束位置
}
}
// 更新全局最大值
maxCount = max(maxCount, count);
}
// 输出结果
cout << maxCount << endl;
return 0;
}
🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2025 B卷 200分）
🏆本文收录于，华为OD机试真题（Python/JS/C/C++）
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。
扫一扫
241
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
