专栏导读
本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。
一、题目描述
给定一个数组，我们称其中连续的元素为连续子序列，称这些元素的和为连续子序列的和。
数组中可能存在几个连续子序列，组内的连续子序列互不交叉且有相同的和。
求一组连续子序列，组内子序列的数目最多。
输出这个数目。
二、输入描述
第一行输入为数组长度 N，1 <= N <= 103
第二行为 N 个用空格分隔的整数 Ci，-105 <= Ci <= 105
三、输出描述
第一行是一个整数 M，表示满足最多的组内子序列的数目。
四、测试用例
测试用例1：
1、输入
10
8 8 9 1 9 6 3 9 1 0
2、输出
4
3、说明
测试用例2：
1、输入
10
-1 0 4 -3 6 5 -6 5 -7 -3
2、输出
3
3、说明
货物1为干货，由1辆干货中转车中转，限载为3
货物2、货物3、货物4为湿货，由1辆湿货中转车中转，限载为16
这样中转车统一限载货物数可以设置为16（干货车和湿货车限载最大值），是最小的取值
五、解题思路
先用前缀和把任意连续子序列和转成 sum = pre[j+1]-pre[i]。
枚举所有子序列 (i, j)，把它们按 sum 分组。
对每个 sum 的子序列列表，按“结束位置”升序排序，使用区间调度的贪心策略（选最早结束的、且与上一个不重叠）求最多不交叉子序列数。
取所有 sum 的最大计数作为答案。
六、Python算法源码
import sys
def main():
data = sys.stdin.read().strip().split()
if not data:
return
n = int(data[0])
a = list(map(int, data[1:1+n]))
# 前缀和，使用 Python int 可自动扩展
pre = [0] * (n + 1)
for i in range(n):
pre[i+1] = pre[i] + a[i]
from collections import defaultdict
mp = defaultdict(list)
# 枚举所有子序列
for i in range(n):
for j in range(i, n):
s = pre[j+1] - pre[i]
mp[s].append((i, j))
ans = 0
for intervals in mp.values():
# 按结束位置排序
intervals.sort(key=lambda x: (x[1], x[0]))
cnt = 0
last_end = -1
# 贪心选择不重叠区间
for st, ed in intervals:
if st > last_end:
cnt += 1
last_end = ed
ans = max(ans, cnt)
print(ans)
if __name__ == "__main__":
main()
七、JavaScript算法源码
'use strict';
const fs = require('fs');
const input = fs.readFileSync(0, 'utf8').trim().split(/\s+/);
if (input.length === 0) process.exit(0);
let idx = 0;
const n = parseInt(input[idx++], 10);
const a = [];
for (let i = 0; i < n; i++) a.push(parseInt(input[idx++], 10));
// 前缀和
const pre = new Array(n + 1).fill(0);
for (let i = 0; i < n; i++) pre[i + 1] = pre[i] + a[i];
// sum -> 区间列表
const mp = new Map();
// 枚举所有子序列
for (let i = 0; i < n; i++) {
for (let j = i; j < n; j++) {
const s = pre[j + 1] - pre[i];
if (!mp.has(s)) mp.set(s, []);
mp.get(s).push([i, j]);
}
}
let ans = 0;
for (const intervals of mp.values()) {
// 按结束位置排序
intervals.sort((x, y) => (x[1] - y[1]) || (x[0] - y[0]));
let cnt = 0;
let lastEnd = -1;
// 贪心选择不重叠区间
for (const seg of intervals) {
if (seg[0] > lastEnd) {
cnt++;
lastEnd = seg[1];
}
}
if (cnt > ans) ans = cnt;
}
console.log(ans);
八、C算法源码
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int l, r;
} Interval;
typedef struct {
long long sum;
Interval *arr;
int size;
int cap;
} Bucket;
// 比较函数：按 r 升序，再按 l 升序
int cmp_interval(const void *a, const void *b) {
const Interval *x = (const Interval *)a;
const Interval *y = (const Interval *)b;
if (x->r != y->r) return x->r - y->r;
return x->l - y->l;
}
// 线性查找桶（n<=1000, O(n^2) 可以接受）
int find_bucket(Bucket *buckets, int bsz, long long sum) {
for (int i = 0; i < bsz; i++) {
if (buckets[i].sum == sum) return i;
}
return -1;
}
int main() {
int n;
if (scanf("%d", &n) != 1) return 0;
int *a = (int *)malloc(sizeof(int) * n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
long long *pre = (long long *)malloc(sizeof(long long) * (n + 1));
pre[0] = 0;
for (int i = 0; i < n; i++) pre[i + 1] = pre[i] + a[i];
Bucket *buckets = (Bucket *)malloc(sizeof(Bucket) * (n * n + 1));
int bsz = 0;
// 枚举所有子序列
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
long long sum = pre[j + 1] - pre[i];
int idx = find_bucket(buckets, bsz, sum);
if (idx == -1) {
buckets[bsz].sum = sum;
buckets[bsz].size = 0;
buckets[bsz].cap = 8;
buckets[bsz].arr = (Interval *)malloc(sizeof(Interval) * buckets[bsz].cap);
idx = bsz++;
}
Bucket *bk = &buckets[idx];
if (bk->size == bk->cap) {
bk->cap *= 2;
bk->arr = (Interval *)realloc(bk->arr, sizeof(Interval) * bk->cap);
}
bk->arr[bk->size++] = (Interval){i, j};
}
}
int ans = 0;
for (int i = 0; i < bsz; i++) {
Bucket *bk = &buckets[i];
qsort(bk->arr, bk->size, sizeof(Interval), cmp_interval);
int cnt = 0;
int lastEnd = -1;
// 贪心选择不重叠区间
for (int k = 0; k < bk->size; k++) {
if (bk->arr[k].l > lastEnd) {
cnt++;
lastEnd = bk->arr[k].r;
}
}
if (cnt > ans) ans = cnt;
}
printf("%d\n", ans);
// 释放内存
for (int i = 0; i < bsz; i++) free(buckets[i].arr);
free(buckets);
free(pre);
free(a);
return 0;
}
九、C++算法源码
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
if (!(cin >> n)) return 0;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
// 前缀和
vector<long long> pre(n + 1, 0);
for (int i = 0; i < n; i++) pre[i + 1] = pre[i] + a[i];
unordered_map<long long, vector<pair<int,int>>> mp;
// 枚举所有子序列
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
long long sum = pre[j + 1] - pre[i];
mp[sum].push_back({i, j});
}
}
int ans = 0;
for (auto &kv : mp) {
auto &intervals = kv.second;
// 按结束位置排序
sort(intervals.begin(), intervals.end(),
[](const auto &x, const auto &y) {
if (x.second != y.second) return x.second < y.second;
return x.first < y.first;
});
int cnt = 0;
int lastEnd = -1;
// 贪心选择不重叠区间
for (auto &seg : intervals) {
if (seg.first > lastEnd) {
cnt++;
lastEnd = seg.second;
}
}
ans = max(ans, cnt);
}
cout << ans << "\n";
return 0;
}
🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 双机位C卷 200分）
🏆本文收录于，华为OD机试真题（Python/JS/C/C++）
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。
扫一扫
999
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
