具有最大和的最长交替子序列

本文将介绍如何使用动态规划算法在一个序列中找到具有最大和的最长交替子序列。我们将展示两种不同的方法，并讨论它们的时间和空间复杂度。

方案一

第一种方法基于以下观察结果：在具有最大和的最长交替子序列中，最后一个元素必定是正数。因此，我们可以使用两个动态规划数组dp_pos和dp_neg来记录以当前位置为结尾的最大正数和最大负数，以及它们之前的最长交替子序列的长度。

具体来说，如果当前元素为正数，则我们更新dp_pos和dp_neg如下：

dp_pos[i] = dp_neg[j] + nums[i]
dp_neg[i] = dp_pos[j] - nums[i]

其中j<i且nums[j]为负数，i为当前位置。如果当前元素为负数，则我们更新dp_pos和dp_neg如下：

dp_pos[i] = dp_pos[j] - nums[i]
dp_neg[i] = dp_neg[j] + nums[i]

代码实现如下：

def max_alternating_subseq(nums):
    n = len(nums)
    dp_pos = [1]*n
    dp_neg = [1]*n
    res = 0
    for i in range(n):
        for j in range(i):
            if nums[i] > 0 and nums[j] < 0 and dp_neg[j] + 1 > dp_pos[i]:
                dp_pos[i] = dp_neg[j] + 1
            elif nums[i] < 0 and nums[j] > 0 and dp_pos[j] + 1 > dp_neg[i]:
                dp_neg[i] = dp_pos[j] + 1
        res = max(res, dp_pos[i], dp_neg[i])
    return res

该算法的时间复杂度为$O(n^2)$，空间复杂度为$O(n)$。

方案二

第二种方法是一种更高效的解决方案，其基于以下分析结果：在一个最长交替子序列中，根据交替的定义，最长的交替子序列必定以正数、负数或零开始。因此，我们可以使用三个动态规划数组dp_pos、dp_neg和dp_zero来记录以当前位置为结尾的最大正数、最大负数或0的和，以及它们之前的最长交替子序列的长度。

具体来说，如果当前元素为正数，则我们更新dp_pos和dp_neg如下：

dp_pos[i] = max(dp_neg[j], dp_zero[j]) + nums[i]
dp_neg[i] = dp_neg[j]

其中j<i且nums[j]为负数或0。如果当前元素为负数，则我们更新dp_pos和dp_neg如下：

dp_pos[i] = dp_pos[j]
dp_neg[i] = max(dp_pos[j], dp_zero[j]) - nums[i]

其中j<i且nums[j]为正数或0。如果当前元素为0，则我们更新dp_zero如下：

dp_zero[i] = max(dp_pos[j], dp_neg[j], dp_zero[j])

其中j<i。然后，我们返回dp_pos、dp_neg和dp_zero中的最大值。

代码实现如下：

def max_alternating_subseq(nums):
    n = len(nums)
    dp_pos = [0]*n
    dp_neg = [0]*n
    dp_zero = [0]*n
    res = 0
    for i in range(n):
        for j in range(i):
            if nums[i] > 0:
                if nums[j] < 0 or nums[j] == 0:
                    dp_pos[i] = max(dp_pos[i], dp_neg[j], dp_zero[j]) + nums[i]
            elif nums[i] < 0:
                if nums[j] > 0 or nums[j] == 0:
                    dp_neg[i] = max(dp_neg[i], dp_pos[j], dp_zero[j]) - nums[i]
            else:
                dp_zero[i] = max(dp_pos[j], dp_neg[j], dp_zero[j])
        res = max(res, dp_pos[i], dp_neg[i], dp_zero[i])
    return res

该算法的时间复杂度为$O(n^2)$，空间复杂度为$O(n)$。因此，与方案一相比，并没有实质上的优势。