将数组拆分为三个连续的子数组，分别为负积、0 积和正积

在程序设计中经常会遇到将数组拆分为不同的子数组的情况，其中一个常见的需求是将数组按照元素的正负性和是否为 0 进行分类。本文将介绍如何使用 Python 实现将数组拆分为三个连续的子数组，分别为负积、0 积和正积。

算法原理

对于一个给定的数组，可以遍历每个元素，维护三个变量 $neg$、$zero$ 和 $pos$，分别表示以当前元素为结尾的负积、0 积和正积的最大值。

具体来说，可以使用动态规划的思想，递推计算出 $neg$、$zero$ 和 $pos$ 的值：

1. 如果当前元素为负数，则 $neg$ 取前一个元素的 $neg$ 与 $pos$ 中较大的值，$zero$ 和 $pos$ 均加上 1。
2. 如果当前元素为 0，则 $zero$ 取前一个元素的 $zero$ 加 1，$neg$ 和 $pos$ 均加上 1。
3. 如果当前元素为正数，则 $pos$ 取前一个元素的 $pos$ 与 $neg$ 中较大的值，$zero$ 和 $neg$ 均加上 1。

遍历完整个数组后，$pos$ 的值即是以数组最后一个元素为结尾的正积的最大值，$neg$ 的值即是以数组最后一个元素为结尾的负积的最大值，$zero$ 的值即是以数组最后一个元素为结尾的 0 积的最大值。

根据求解出的 $pos$、$neg$ 和 $zero$ 的最大值，可以将数组拆分为三个连续的子数组，分别为正积、负积和 0 积。具体拆分方法如下：

1. 如果 $pos$ 的值大于 $neg$ 和 $zero$ 的值的和，则以 $pos$ 为结尾的正积形成的连续子数组最长，将数组从 $pos$ 的位置处拆分。
2. 如果 $neg$ 的值大于 $pos$ 和 $zero$ 的值的和，则以 $neg$ 为结尾的负积形成的连续子数组最长，将数组从 $neg$ 的位置处拆分。
3. 否则，以 $zero$ 为结尾的 0 积形成的连续子数组最长，将数组从 $zero$ 的位置处拆分。

代码实现

下面是基于 Python 实现的将数组拆分为三个连续的子数组，分别为负积、0 积和正积的代码。其中，$nums$ 是输入的数组，$start$ 和 $end$ 分别是拆分后三个子数组的起始和结束下标。

def split_array(nums: List[int]) -> List[int]:
    n = len(nums)
    
    # 初始化
    pos, neg, zero = (1 if nums[i] > 0 else 0 for i in range(n)), (1 if nums[i] < 0 else 0 for i in range(n)), (1 if nums[i] == 0 else 0 for i in range(n))
    
    # 动态规划
    for i in range(1, n):
        if nums[i] > 0:
            pos[i] = max(pos[i-1], neg[i-1]+1)
            neg[i] = neg[i-1]+1
        elif nums[i] < 0:
            neg[i] = max(neg[i-1], pos[i-1]+1)
            pos[i] = pos[i-1]+1
        else:
            zero[i] = zero[i-1]+1
    
    # 拆分数组
    max_val = max(pos[i], neg[i], zero[i])
    if max_val == pos[i]:
        end = i
        while pos[end-1] == pos[i]:
            end -= 1
        start = end - pos[i] + 1
    elif max_val == neg[i]:
        end = i
        while neg[end-1] == neg[i]:
            end -= 1
        start = end - neg[i] + 1
    else:
        end = i
        while zero[end-1] == zero[i]:
            end -= 1
        start = end - zero[i] + 1
    
    return [start, end]

性能分析

本算法的时间复杂度为 $O(n)$，其中 $n$ 是数组的长度。空间复杂度为 $O(n)$，需要维护数组 $pos$、$neg$ 和 $zero$。

在实际应用中，$n$ 的数量级通常不会很大，因此本算法的性能表现良好。