AI推理任务并行额度最大值(2026.10.28)
2026年最新华为OD机考题库(按考点分类): 2026年最新华为OD机考题库
题目描述
有 n 个 AI 推理任务按序排队,第 i 个任务需占用 vram[i] GB 显存。调度器可选定一个任务 i 为基准,向左右连续合并相邻任务,即选择一个包含任务 i 的连续子数组。
合并条件是:被合并任务的显存占用不低于 vram[i]。
已知任务的并行执行额度值为:
并行执行额度值 = vram[i] × 任务个数
其中,任务个数为满足合并条件的连续子数组长度,包含基准任务本身。对于给定的任务序列 vram,请计算该序列中可达到的并行执行额度最大值。
输入描述
n:任务数量;vram:长度为 n 的整数数组。
数据范围
1≤n≤105,0≤ vram[i] ≤104。
输出描述
返回一个整数,表示最大并行执行额度。
样例
用例输入 1
6,[2,1,5,6,2,3]
用例输出 1
10
用例解释 1
- 以第 3 个任务为基准,显存占用为 5 GB,可以向右合并显存占用为 6 GB 的第 4 个任务,共包含 2 个任务,额度为 5 × 2 = 10。左侧的第 2 个任务和右侧的第 5 个任务均低于 5 GB,无法继续合并。
- 以第 2 个任务为基准时,可以合并全部 6 个任务,额度为 1 × 6 = 6。比较所有选择,最大额度为 10。
用例输入 2
4,[4,4,4,4]
用例输出 2
16
用例解释 2
- 相同显存也满足“不低于”的条件,可以将全部 4 个任务合并,额度为 4 × 4 = 16。
来源
本题来源于网络、非官方材料、仅供学习交流,侵删
🧠 解题思路
第一步:题目在问什么
选一个任务 i 当基准,从它开始向左、向右合并相邻任务,只要相邻任务的显存不低于 vram[i] 就能继续合并,碰到更低的就停。额度 = vram[i] × 合并后的长度。对所有基准取最大额度。
第二步:每个基准能合并多远
以 i 为基准,向左一直合并到“左边第一个显存严格小于 vram[i] 的任务”之前,向右一直合并到“右边第一个严格小于 vram[i] 的任务”之前。设这两个位置是 L、R(左边没有更小的就当 L = −1,右边没有就当 R = n),合并后的区间是 [L+1, R−1],长度是 R − L − 1。
所以问题变成:对每个位置,求左边、右边第一个比它小的位置。
第三步:最直接的做法为什么慢
对每个 i 分别向左、向右一个个找。如果显存全都相同,每个 i 都要走完整个数组,n = 10⁵ 时约 10¹⁰ 步,会超时。
第四步:单调栈求“左边第一个更小的”
从左往右扫,用一个栈存下标,保证栈里的显存从底到顶严格递增。扫到 i 时:
- 把栈顶显存 ≥ vram[i] 的下标都弹出去;
- 弹完后,栈顶就是 i 左边第一个显存比它小的位置(栈空说明左边没有,合并到最左端);
- 把 i 压进栈。
为什么第 1 步弹出的下标以后都没用了?被弹出的下标在 i 左边,显存又不比 vram[i] 小。对 i 右边的任何任务,i 离它更近、显存还不比被弹出的大:被弹出的如果比它小,i 也比它小,而且 i 更近,所以“第一个更小的”轮不到被弹出的那个。
每个下标只进栈、出栈各一次,扫一遍是 O(n)。栈里的值始终有序,所以叫单调栈。
“右边第一个更小的”同样做法,从右往左扫一遍。
第五步:算答案
求出每个 i 的合并区间 [left[i], right[i]] 后,额度 = vram[i] × (right[i] − left[i] + 1),取最大值。
最优方案一定会在某个基准上被算到:最优的那段里显存最小的任务当基准,正好能合并出这一段。
用样例 1 走一遍
vram = [2, 1, 5, 6, 2, 3]:
| i | 显存 | 左边第一个更小 | 右边第一个更小 | 合并区间 | 长度 | 额度 |
|---|---|---|---|---|---|---|
| 0 | 2 | 无 | 下标 1(1) | [0, 0] | 1 | 2 |
| 1 | 1 | 无 | 无 | [0, 5] | 6 | 6 |
| 2 | 5 | 下标 1(1) | 下标 4(2) | [2, 3] | 2 | 10 |
| 3 | 6 | 下标 2(5) | 下标 4(2) | [3, 3] | 1 | 6 |
| 4 | 2 | 下标 1(1) | 无 | [2, 5] | 4 | 8 |
| 5 | 3 | 下标 4(2) | 无 | [5, 5] | 1 | 3 |
最大额度 10:以 5 为基准,合并 5、6 两个任务。
样例 2:[4, 4, 4, 4]。相等的可以合并,所以找的是“严格更小”,每个位置都能合并整个数组,额度 4 × 4 = 16。
⚠️ 易错点
- 显存相等的任务可以合并,边界找的是“严格小于”的位置:弹栈条件写“栈顶 ≥ 当前”。
- 合并区间是 [L+1, R−1],长度 R − L − 1,左右两端的那个更小的任务本身不算进去。
- 额度最大 10⁴ × 10⁵ = 10⁹,乘法要用 long / long long,避免中间溢出。
- n = 1 时答案就是 vram[0]。
⏱️ 复杂度
时间复杂度:O(n),两次单调栈各扫一遍,每个下标进出栈各一次;n 不超过 10⁵。
空间复杂度:O(n),左右边界数组和栈。
💻 参考代码(Java)
class Solution {
public long maxParallelQuota(int n, int[] vram) {
// 单调栈求左右第一个严格小于当前值的位置
int[] left = new int[n];
int[] right = new int[n];
int[] st = new int[n];
int top = 0;
for (int i = 0; i < n; i++) {
while (top > 0 && vram[st[top - 1]] >= vram[i]) top--;
left[i] = top == 0 ? 0 : st[top - 1] + 1;
st[top++] = i;
}
top = 0;
for (int i = n - 1; i >= 0; i--) {
while (top > 0 && vram[st[top - 1]] >= vram[i]) top--;
right[i] = top == 0 ? n - 1 : st[top - 1] - 1;
st[top++] = i;
}
long ans = 0;
for (int i = 0; i < n; i++) {
long cur = (long) vram[i] * (right[i] - left[i] + 1);
if (cur > ans) ans = cur;
}
return ans;
}
}
💻 参考代码(C++)
class Solution {
public:
long long maxParallelQuota(int n, vector<int>& vram) {
// 单调栈求左右第一个严格小于当前值的位置
vector<int> left(n), right(n);
vector<int> st;
for (int i = 0; i < n; ++i) {
while (!st.empty() && vram[st.back()] >= vram[i]) st.pop_back();
left[i] = st.empty() ? 0 : st.back() + 1;
st.push_back(i);
}
st.clear();
for (int i = n - 1; i >= 0; --i) {
while (!st.empty() && vram[st.back()] >= vram[i]) st.pop_back();
right[i] = st.empty() ? n - 1 : st.back() - 1;
st.push_back(i);
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
long long cur = 1LL * vram[i] * (right[i] - left[i] + 1);
if (cur > ans) ans = cur;
}
return ans;
}
};
💻 参考代码(Python)
class Solution:
def maxParallelQuota(self, n: int, vram: list) -> int:
# 单调栈求左右第一个严格小于当前值的位置
left = [0] * n
right = [n - 1] * n
st = []
for i in range(n):
while st and vram[st[-1]] >= vram[i]:
st.pop()
left[i] = st[-1] + 1 if st else 0
st.append(i)
st = []
for i in range(n - 1, -1, -1):
while st and vram[st[-1]] >= vram[i]:
st.pop()
right[i] = st[-1] - 1 if st else n - 1
st.append(i)
ans = 0
for i in range(n):
cur = vram[i] * (right[i] - left[i] + 1)
if cur > ans:
ans = cur
return ans
💻 参考代码(JavaScript)
class Solution {
maxParallelQuota(n, vram) {
// 单调栈求左右第一个严格小于当前值的位置
const left = new Array(n);
const right = new Array(n);
let st = [];
for (let i = 0; i < n; i++) {
while (st.length && vram[st[st.length - 1]] >= vram[i]) st.pop();
left[i] = st.length ? st[st.length - 1] + 1 : 0;
st.push(i);
}
st = [];
for (let i = n - 1; i >= 0; i--) {
while (st.length && vram[st[st.length - 1]] >= vram[i]) st.pop();
right[i] = st.length ? st[st.length - 1] - 1 : n - 1;
st.push(i);
}
let ans = 0;
for (let i = 0; i < n; i++) {
const cur = vram[i] * (right[i] - left[i] + 1);
if (cur > ans) ans = cur;
}
return ans;
}
}
module.exports = { Solution };
866



被折叠的 条评论
为什么被折叠?



