LeetCode 热题 HOT 100 Java题解——53. 最大子序和

53. 最大子序和

题目：
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例：

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

动态规划

这道题动态规划非常的简单，用$dp[i]$表示第$i$位结尾的最大子数组的大小，那么当$dp[i-1]$小于$0$的时候，最大子数组就是$dp[i]=nums[i]$，否则为$dp[i]=dp[i-1]+nums[i]$，由于每个$dp[i]$只使用一次，我们可以只用一个$dp$变量来记录之前的子数组最大值，节省空间，过程中记录出现过的最大值即可，代码如下：

class Solution {
    public int maxSubArray(int[] nums) {
        int max = nums[0], dp = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (dp <= 0) dp = nums[i];
            else dp += nums[i];
            max = Math.max(max, dp);
        }
        return max;
    }
}

复杂度分析

• 时间复杂度：$O(n)$

  循环一遍，复杂度为$O(n)$。

• 空间复杂度：$O(1)$

  仅需要常数级额外变量。

分治法

题目明确要求使用分治法，因此可以作为了解，实际上，分治法的复杂度并没有动态规划方法的复杂度好。

分治法主要是递归的拆解数组为左右两部分，当拆解到一个元素时开始返回，并“组装”每两部分。

假设拆解到$[l,r]$这一个部分为$[l,m]$和$[m+1,r]$，那么我们要想合并需要维护这样几个变量：

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

那么，合并返回的时候各个值的求法分别为：

1. $lSum$为$max($$[l,m]$的$lSum$, $[l,m]$的$iSum$加上$[m+1,r]$的$lSum$$)$
2. 同上，$max($两种情况$)$
3. 三种情况取最大值：
   1. $[l,m]$的$mSum$
   2. $[m+1,r]$的$mSum$
   3. $[l,m]$的$rSum+[m+1,r]$的$lSum$
4. $[l,r]$的$iSum$为$[l,m]$和$[m+1,r]$的$iSum$之和

class Solution {
    public class 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 Status getInfo(int[] nums, int l, int r) {
        if(l == r) return new Status(nums[l], nums[l], nums[l], nums[l]);
        int m = l + (r - l) / 2;
        Status left = getInfo(nums, l , m);
        Status right = getInfo(nums, m + 1, r);
        int lSum = Math.max(left.lSum, left.iSum + right.lSum);
        int rSum = Math.max(right.rSum, right.iSum + left.rSum);
        int mSum = Math.max(left.rSum + right.lSum, Math.max(left.mSum, right.mSum));
        int iSum = left.iSum + right.iSum;
        return new Status(lSum, rSum, mSum, iSum);
    }
    public int maxSubArray(int[] nums) {
        return getInfo(nums, 0 , nums.length - 1).mSum;
    }
}

线段树这种数据结构就是使用了这种分治的思想，使得所有操作都可以在$O(logn)$的时间内得到答案。

复杂度分析

• 时间复杂度：$O(n)$

  遍历了所有节点。

• 空间复杂度：$O(logn)$

  递归深度$logn$故使用栈开销$O(logn)$。