LeetCode 53. 最大子序和（Python、动态规划、分治（线段树））

学习分治（线段树） 的应用，同时记住递归的空间复杂度（栈的深度）

题目描述

方法一：动态规划

思路和算法

假设 nums 数组的长度是 $n$，下标从 $0$ 到 $n-1$。

我们用 $a_i$ 代表 $nums[i]$，用 $dp(i)$ 代表以第 $i$ 个数结尾的「连续子数组的最大和」，那么很显然我们要求的答案就是：

$$\underset{0\le i\le n-1}{\max }f(i)$$

因此我们只需要求出每个位置的 $dp(i)$，然后返回 dp 数组中的最大值即可。那么我们如何求 $dp(i)$ 呢？我们可以考虑 $a_i$ 单独成为一段还是加入 $dp(i-1)$ 对应的那一段，这取决于 $a_i$ 和 $dp(i-1)+a_i$ 的大小，我们希望获得一个比较大的，于是可以写出这样的动态规划转移方程：
d p ( i ) = max ⁡ { d p ( i − 1 ) + a i , a i } dp(i) = \max \{ dp(i - 1) + a_i, a_i \} dp(i)=max{dp(i−1)+ai​,ai​}

不难给出一个时间复杂度 $O(n)$、空间复杂度 $O(n)$ 的实现，即用一个 dp 数组来保存 $dp(i)$ 的值，用一个循环求出所有 $dp(i)$。

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        dp = []  # 以nums[i]结尾的最大连续子数组和
        maxsum = nums[0]
        for i in range(len(nums)):
            if i == 0 or dp[i-1] <= 0:
                dp.append(nums[i])
            elif dp[i-1] > 0:
                dp.append(dp[i-1] + nums[i])
            if dp[i] > maxsum:
                maxsum = dp[i]
        return maxsum

更进一步的，考虑到 $dp(i)$ 只和 $dp(i-1)$ 相关，于是我们可以只用一个变量 pre 来维护对于当前 $dp(i)$ 的 $dp(i-1)$ 的值是多少，从而让空间复杂度降低到 $O(1)$，这有点类似「滚动数组」的思想。

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        pre = 0
        maxsum = nums[0]
        for i in range(len(nums)):
            pre = max(nums[i], pre + nums[i])
            maxsum = max(maxsum, pre)
        return maxsum

复杂度

• 时间复杂度：$O(n)$，其中 $n$ 为 nums 数组的长度。我们只需要遍历一遍数组即可求得答案。
• 空间复杂度：$O(1)$，我们只需要常数空间存放若干变量。

方法二：分治

思路和算法

这个分治方法类似于「线段树求解 LCIS 问题」的 pushUp 操作。 也许读者还没有接触过线段树，没有关系，方法二的内容假设你没有任何线段树的基础。当然，如果读者有兴趣的话，推荐看一看线段树区间合并法解决 多次询问 的「区间最长连续上升序列问题」和「区间最大子段和问题」，还是非常有趣的。

我们定义一个操作 get(a, l, r) 表示查询 $a$ 序列 $[l,r]$ 区间内的最大子段和，那么最终我们要求的答案就是 get(nums, 0, nums.size() - 1)。如何分治实现这个操作呢？对于一个区间 $[l,r]$，我们取 $m=\lfloor \frac{l+r}{2}\rfloor$，对区间 $[l,m]$ 和 $[m+1,r]$ 分治求解。当递归逐层深入直到区间长度缩小为 $1$ 的时候，递归「开始回升」。这个时候我们考虑如何通过 $[l,m]$ 区间的信息和 $[m+1,r]$ 区间的信息合并成区间 $[l,r]$ 的信息。最关键的两个问题是：

• 我们要维护区间的哪些信息呢？
• 我们如何合并这些信息呢？

对于一个区间 $[l,r]$，我们可以维护四个量：

• lSum 表示 $[l,r]$ 内以 $l$ 为左端点的最大子段和
• rSum 表示 $[l,r]$ 内以 $r$ 为右端点的最大子段和
• mSum 表示 $[l,r]$ 内的最大子段和
• iSum 表示 $[l,r]$ 的区间和

以下简称 $[l,m]$ 为 $[l,r]$ 的「左子区间」，$[m+1,r]$ 为 $[l,r]$ 的「右子区间」。我们考虑如何维护这些量呢（如何通过左右子区间的信息合并得到 $[l,r]$ 的信息）？对于长度为 $1$ 的区间 $[i,i]$，四个量的值都和 $a_i$ 相等。对于长度大于 $1$ 的区间：

• 首先最好维护的是 iSum，区间 $[l,r]$ 的 iSum 就等于「左子区间」的 iSum 加上「右子区间」的 iSum。
• 对于 $[l,r]$ 的 lSum，存在两种可能，它要么等于「左子区间」的 lSum，要么等于「左子区间」的 iSum 加上「右子区间」的 lSum，二者取大。
• 对于 $[l,r]$ 的 rSum，同理，它要么等于「右子区间」的 rSum，要么等于「右子区间」的 iSum 加上「左子区间」的 rSum，二者取大。
• 当计算好上面的三个量之后，就很好计算 $[l,r]$ 的 mSum 了。我们可以考虑 $[l,r]$ 的 mSum 对应的区间是否跨越 $m$——它可能不跨越 $m$，也就是说 $[l,r]$ 的 mSum 可能是「左子区间」的 mSum 和「右子区间」的 mSum 中的一个；它也可能跨越 $m$，可能是「左子区间」的 rSum 和 「右子区间」的 lSum 求和。三者取大。

这样问题就得到了解决。

class Status():
        def __init__(self):
            self.lSum = None
            self.rSum = None
            self.mSum = None
            self.iSum = None


class Solution:
    def pushUp(self, lSub_Status, rSub_Status):
        '''
        合成两个子区间的Status
        '''
        status = Status()
        status.lSum = max(lSub_Status.lSum, lSub_Status.iSum + rSub_Status.lSum)
        status.rSum = max(rSub_Status.rSum, rSub_Status.iSum + lSub_Status.rSum)
        status.mSum = max(lSub_Status.mSum, rSub_Status.mSum, lSub_Status.rSum + rSub_Status.lSum)
        status.iSum = lSub_Status.iSum + rSub_Status.iSum
        return status

    def get(self, nums, left, right):
        '''
        获得nums[left, right]区间上的Status
        '''
        status = Status()
        if left == right:
            status.lSum = nums[left]
            status.rSum = nums[left]
            status.mSum = nums[left]
            status.iSum = nums[left]
            return status

        # 分治
        m = (left + right) // 2
        lSub_Status = self.get(nums, left, m)
        rSub_Status = self.get(nums, m+1, right)
        return self.pushUp(lSub_Status, rSub_Status)

    def maxSubArray(self, nums: List[int]) -> int:
        return self.get(nums, 0, len(nums) - 1).mSum

复杂度分析

假设序列 $a$ 的长度为 $n$。

• 时间复杂度：假设我们把递归的过程看作是一颗二叉树的先序遍历，那么这颗二叉树的深度的渐进上界为 $O(\log n)$，这里的总时间相当于遍历这颗二叉树的所有节点，故总时间的渐进上界是 $O({\sum }_{i=1}^{\log n}{2}^{i-1})=O(n)$，故渐进时间复杂度为 $O(n)$。
• 空间复杂度：递归会使用 $O(\log n)$ 的栈空间，故渐进空间复杂度为 $O(\log n)$。

题外话

「方法二」相较于「方法一」来说，时间复杂度相同，但是因为使用了递归，并且维护了四个信息的结构体，运行的时间略长，空间复杂度也不如方法一优秀，而且难以理解。那么这种方法存在的意义是什么呢？

对于这道题而言，确实是如此的。但是仔细观察「方法二」，它不仅可以解决区间 $[0,n-1]$，还可以用于解决任意的子区间 $[l,r]$ 的问题。如果我们把 $[0,n-1]$ 分治下去出现的所有子区间的信息都用堆式存储的方式记忆化下来，即建成一颗真正的树之后，我们就可以在 $O(\log n)$ 的时间内求到任意区间内的答案，我们甚至可以修改序列中的值，做一些简单的维护，之后仍然可以在 $O(\log n)$ 的时间内求到任意区间内的答案，对于大规模查询的情况下，这种方法的优势便体现了出来。这棵树就是上文提及的一种神奇的数据结构——线段树。