leetcode-42.连续子数组的最大和

1. 问题描述

输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为O(n)。

示例1:

输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
leetcode 42.连续子数组的最大和

2. 问题分析

1. 动态规划

假设 $\text{nums}$ 数组的长度是 $n$，下标从 0 到 n−1。我们用 $f(i)$ 代表以第 $i$ 个数结尾的「连续子数组的最大和」，那么很显然我们要求的答案就是： max ⁡ 0 ≤ i ≤ n − 1 { f ( i ) } \max_{0 \leq i \leq n-1} \{ f(i) \} 0≤i≤n−1max​{f(i)}因此我们只需要求出每个位置的 $f(i)$，然后返回 $f$ 数组中的最大值即可。那么我们如何求 $f(i)$ 呢？我们可以考虑 $\text{nums}[i]$ 单独成为一段还是加入 $f(i-1)$ 对应的那一段，这取决于 $\text{nums}[i]$ 和 $f(i-1)+\text{nums}[i]$ 的大小，我们希望获得一个比较大的，于是可以写出这样的动态规划转移方程： f ( i ) = max ⁡ { f ( i − 1 ) + nums [ i ] , nums [ i ] } f(i) = \max \{ f(i-1) + \textit{nums}[i], \textit{nums}[i] \} f(i)=max{f(i−1)+nums[i],nums[i]}不难给出一个时间复杂度 $O(n)$、空间复杂度 $O(n)$ 的实现，即用一个 $f$ 数组来保存 $f(i)$ 的值，用一个循环求出所有 $f(i)$。考虑到 $f(i)$ 只和 $f(i-1)$ 相关，于是我们可以只用一个变量 $\text{pre}$ 来维护对于当前 $f(i)$ 的 $f(i-1)$ 的值是多少，从而让空间复杂度降低到 $O(1)$，这有点类似「滚动数组」的思想。

class Solution {
    public int maxSubArray(int[] nums) {
        int pre = 0, maxAns = nums[0];
        for (int x : nums) {
            pre = Math.max(pre + x, x);
            maxAns = Math.max(maxAns, pre);
        }
        return maxAns;
    }
}

2. 分治法

这个分治方法类似于「线段树求解最长公共上升子序列问题」的 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]$，我们可以维护四个量：
（1）$\text{lSum}$ 表示 $[l,r]$ 内以 $l$ 为左端点的最大子段和
（2）$\text{rSum}$表示 $[l,r]$ 内以 $r$ 为右端点的最大子段和
（3）$\text{mSum}$ 表示 $[l,r]$ 内的最大子段和
（4）$\text{iSum}$ 表示 $[l,r]$ 的区间和
以下简称 $[l,m]$ 为 $[l,r]$ 的「左子区间」，$[m+1,r]$ 为 $[l,r]$ 的「右子区间」。我们考虑如何维护这些量呢（如何通过左右子区间的信息合并得到 $[l,r]$ 的信息）？对于长度为 1 的区间 $[i,i]$，四个量的值都和 $\text{nums}[i]$ 相等。对于长度大于 1 的区间：
首先最好维护的是 $\text{iSum}$，区间 $[l,r]$ 的 $\text{iSum}$ 就等于「左子区间」的 $\text{iSum}$ 加上「右子区间」的 $\text{iSum}$。
对于 $[l,r]$ 的 $\text{lSum}$，存在两种可能，它要么等于「左子区间」的 $\text{lSum}$，要么等于「左子区间」的 $\text{iSum}$ 加上「右子区间」的 $\text{lSum}$，二者取大。
对于 $[l,r]$ 的 $\text{rSum}$，同理，它要么等于「右子区间」的 $\text{rSum}$，要么等于「右子区间」的 $\text{iSum}$ 加上「左子区间」的 $\text{rSum}$，二者取大。
当计算好上面的三个量之后，就很好计算 $[l,r]$ 的 $\text{mSum}$ 了。我们可以考虑 $[l,r]$ 的 $\text{mSum}$ 对应的区间是否跨越 $m$——它可能不跨越 $m$，也就是说 $[l,r]$ 的 $\text{mSum}$ 可能是「左子区间」的 $\text{mSum}$ 和 「右子区间」的 $\text{mSum}$ 中的一个；它也可能跨越 $m$，可能是「左子区间」的 $\text{rSum}$ 和 「右子区间」的 $\text{lSum}$ 求和。三者取大。
这样问题就得到了解决

class Solution {
    public class Status{										//内部类：定义Status类
        public int lSum, rSum, mSum, iSum;
        public Status(int lSum, int rSum, int mSum, int iSum){
            this.lSum = lSum;
            this.rSum = rSum;
            this.mSum = mSum;
            this.iSum = iSum;
        }
    }
    
    public int maxSubArray(int[] nums){
        return getInfo(nums, 0, nums.length - 1).mSum;
    }

    public Status getInfo(int[] a, int left, int right){				//递归更新左右状态信息
        if(left == right)												//此时数组只有一个元素
            return new Status(a[left], a[left], a[left], a[left]);

        int mid = (left + right) >> 1;									//从中间划分区间
        Status lSub = getInfo(a, left, mid);							//求左边的状态
        Status rSub = getInfo(a, mid + 1, right);						//求右边的状态
        return pushUp(lSub, rSub);
    }

    public Status pushUp(Status lSub, Status rSub) {					//合并左右区间的信息
        int iSum = lSub.iSum + rSub.iSum;										
        int lSum = Math.max(lSub.lSum, lSub.iSum + rSub.lSum);
        int rSum = Math.max(rSub.rSum, rSub.iSum + lSub.rSum);
        int mSum = Math.max(Math.max(lSub.mSum, rSub.mSum), lSub.rSum + rSub.lSum);
        return new Status(lSum, rSum, mSum, iSum);
    }
}