17370845950

本文介绍一种高效算法，用于在 o(n) 时间、o(1) 空间内求解由数组 `a` 构造的特殊前缀累加序列 `b` 的最大元素，避免朴素 o(n²) 暴力构造的开销。

该问题的核心在于理解序列 b 的生成规律。观察题中示例：

b[0] = 0  
b[1] = b[0] + a[0]  
b[2] = b[1] + a[0]  
b[3] = b[2] + a[1]  
b[4] = b[3] + a[0]  
b[5] = b[4] + a[1]  
b[6] = b[5] + a[2]  
b[7] = b[6] + a[0]  
...

可发现 b 是按“轮次（round）”分组构造的：第 i 轮（从 0 开始）新增 i+1 个元素，且每轮内部的增量恰好是 a[0], a[1], ..., a[i] 的前缀——即第 i 轮对应所有长度为 1 到 i+1 的 a 前缀和。

更形式化地，令 S_i = a[0] + a[1] + ... + a[i]，P_{i,j} = a[0] + ... + a[j]（j ≤ i），则第 i 轮起始于 b_start[i]，其生成的元素为：

b_start[i] + P_{i,0},  
b_start[i] + P_{i,1},  
...,  
b_start[i] + P_{i,i}

因此，该轮最大值为 b_start[i] + max{P_{i,0}, ..., P_{i,i}}。

关键洞察在于：

• b_start[i] 就是上一轮最后一个 b 值，即 b_start[i] = b_start[i-1] + S_{i-1}（定义 b_start[0] = 0）；
• max{P_{i,0}, ..., P_{i,i}} 正是 a 的前 i+1 项的最大前缀和，可在遍历 a 时用 max_sum_a = max(max_sum_a, sum_a) 动态维护；
• 因此，无需显式构造整个 b 数组，只需在单次遍历中同步更新：
  • 当前轮起始值 b（即上轮累加和）；
  • 当前已见前缀和的最大值 max_sum_a；
  • 全局最大 b 值 max_b。

以下是清晰、健壮的 O(n)/O(1) 实现：

def find_max_linear(a):
    b = max_b = 0        # b
: 当前轮起始值（即上轮末尾b值）；max_b: 全局最大b
    sum_a = max_sum_a = 0  # sum_a: 当前前缀和；max_sum_a: 当前最大前缀和
    for x in a:
        sum_a += x
        max_sum_a = max(max_sum_a, sum_a)
        max_b = max(max_b, b + max_sum_a)  # 当前轮最大b = 起始b + 最大前缀和
        b += sum_a  # 更新下一轮起始b值：b += 当前完整前缀和
    return max_b

✅ 正确性保障：b[0] = 0 已包含（max_b 初始化为 0），每轮贡献被精确捕获；
⚠️ 注意事项：

• 输入 a 可含负数或零，算法天然支持（max_sum_a 可能为负，但 max_b 始终取 max(0, ...) 隐含逻辑，因 b[0]=0 是合法候选）；
• 若 a 为空，函数返回 0，符合定义；
• 时间复杂度严格 O(n)，空间仅用常数变量。

进阶技巧：借助 itertools.accumulate 可写出函数式风格的一行解（时间仍 O(n)，但空间 O(n) 因中间序列生成）：

from itertools import accumulate
from operator import add

def find_max_linear_oneliner(a):
    acc_a = list(accumulate(a))              # [a0, a0+a1, a0+a1+a2, ...]
    prefix_sums = list(accumulate(acc_a))    # 各轮起始b值：[0, a0, a0+(a0+a1), ...]
    max_prefixes = list(accumulate(acc_a, max))  # 各轮最大前缀和
    return max(0, *map(add, [0] + prefix_sums, [0] + max_prefixes))

但生产环境推荐首选清晰的四变量循环版本——它兼具最优复杂度、高可读性与强鲁棒性。