LeetCode 53. 最大子数组和

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组是数组中的一个连续部分。

示例 1：

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

示例 2：

输入：nums = [1]
输出：1

示例 3：

输入：nums = [5,4,-1,7,8]
输出：23

提示：

• 1 <= nums.length <= 10^5
• -10^4 <= nums[i] <= 10^4

解法1：动态规划

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

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

0≤i≤n−1, max( maxPresum[i] )

因此我们只需要求出每个位置的 maxPresum[i]，然后返回 maxPresum 数组中的最大值即可。那么我们如何求 maxPresum[i] 呢？我们可以考虑 nums[i] 单独成为一段还是加入 maxPresum[i−1] 对应的那一段，这取决于 nums[i] 和 maxPresum[i - 1]+nums[i] 的大小，我们希望获得一个比较大的，于是可以写出这样的动态规划转移方程：

maxPresum[i]=max( (maxPresum[i−1])+nums[i], nums[i])

不难给出一个时间复杂度 O(n)、空间复杂度 O(n) 的实现，即用一个 maxPresum 数组来保存 maxPresum[i] 的值，用一个循环求出所有 maxPresum[i]。考虑到 maxPresum[i] 只和 maxPresum[i - 1] 相关，于是我们可以只用一个变量 maxPresum 来维护对于当前 maxPresum[i] 的 maxPresum[i - 1] 的值是多少，从而让空间复杂度降低到 O(1)，这有点类似「滚动数组」的思想。

Java版：

class Solution {
    public int maxSubArray(int[] nums) {
        int maxPresum = 0;
        int ans = nums[0];
        for (int num: nums) {
            maxPresum = Math.max(maxPresum + num, num);
            ans = Math.max(ans, maxPresum);
        }
        return ans;
    }
}

Python3版：

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        maxPresum = 0
        ans = nums[0]
        for num in nums:
            maxPresum = max(maxPresum + num, num)
            ans = max(ans, maxPresum)
        return ans

复杂度分析

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

解法2：前缀和

由于子数组的元素和等于两个前缀和的差，所以求出 nums 的前缀和，维护最小前缀和，每次比较当前前缀和 减去 最小前缀和的值 和 ans的值 ，取最大值作为答案。

Java版：

class Solution {
    public int maxSubArray(int[] nums) {
        int ans = Integer.MIN_VALUE;
        int presum = 0;
        int min_presum = 0;
        for (int num: nums) {
            presum += num;
            ans = Math.max(ans, presum - min_presum);
            min_presum = Math.min(min_presum, presum);
        }
        return ans;
    }
}

Python3版：

Python math.inf 正无穷大的浮点数，负无穷大，使用 -math.inf 。

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        ans = -math.inf
        presum = 0
        min_presum = 0
        for num in nums:
            presum += num
            ans = max(ans, presum - min_presum)
            min_presum = min(min_presum, presum)
        return ans

复杂度分析

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

解法3：分治  

连续子序列的最大和主要由这三部分子区间里元素的最大和得到：

第 1 部分：子区间 [left, mid]；
第 2 部分：子区间 [mid + 1, right]；
第 3 部分：包含子区间 [mid] 的子区间，即 nums[mid]  一定会被选取，可以从中间向两边扩散，扩散到底 选出最大和；
对这三个部分求最大值即可。

Java版： 

class Solution {
    public int maxSubArray(int[] nums) {
        return maxSubArraySum(nums, 0, nums.length - 1);
    }

    private int maxSubArraySum(int[] nums, int left, int right) {
        if (left == right) {
            return nums[left];
        }
        int mid = left + (right - left) / 2;
        return Math.max( Math.max(maxSubArraySum(nums, left, mid), maxSubArraySum(nums, mid + 1, right)), maxCrossingSum(nums, left, mid, right) );
    }

    // 一定包含 nums[mid] 元素的最大连续子数组的和
    // 思路是看看左边扩散到底，得到一个最大和
    // 右边扩散到底得到一个最大和
    private int maxCrossingSum(int[] nums, int left, int mid, int right) {
        int presum = 0;
        int leftSum = Integer.MIN_VALUE;
        int rightSum = Integer.MIN_VALUE;

        // 左半边包含 nums[mid] 元素，最多可以到什么地方
        // 走到最边界，看看最值是什么
        // 计算以 mid 结尾的最大的子数组的和
        for (int i = mid; i >= left; i--) {
            presum += nums[i];
            leftSum = Math.max(leftSum, presum);
        }

        presum = 0;
        // 右半边不包含 nums[mid] 元素，最多可以到什么地方
        // 计算以 mid+1 开始的最大的子数组的和
        for (int i = mid + 1; i <= right; i++) {
            presum += nums[i];
            rightSum = Math.max(rightSum, presum);
        }
        return leftSum + rightSum;
    }
}

Python3版：

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        def maxCrossingSum(nums, left, mid, right):
            presum = 0
            leftSum = -math.inf
            rightSum = -math.inf
            for i in range(mid, left - 1, -1):
                presum += nums[i]
                leftSum = max(leftSum, presum)
            
            presum = 0
            for i in range(mid + 1, right + 1, 1):
                presum += nums[i]
                rightSum = max(rightSum, presum)
            return leftSum + rightSum

        def maxSubArraySum(nums, left, right):
            if left == right:
                return nums[left]
            mid = left + (right - left) // 2
            return max(maxSubArraySum(nums, left, mid), maxSubArraySum(nums, mid + 1, right), maxCrossingSum(nums, left, mid, right))

        return maxSubArraySum(nums, 0, len(nums) - 1)

复杂度分析

• 时间复杂度：O(nlog⁡n)，这里递归的深度是对数级别的，每一层需要遍历一遍数组（或者数组的一半、四分之一）；
• 空间复杂度：O(log⁡n)，需要常数个变量用于选取最大值，需要使用的空间取决于递归栈的深度。