最大子序和

题目描述

思路一

动态规划
沿数组移动并在原数组修改。
时间复杂度O(n)
空间复杂度O(1)
但是原本的数组会被破坏

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        max_ = nums[0]
        for i in range(1,len(nums)):
            ##此时的nums[n-1]是i索引的值对应的前面的新规划的数组，数组里面的值的和大于0的话，往后面加可能会产生更大的值。
            if nums[i-1] > 0:
                nums[i] += nums[i-1]
            max_ = max(max_,nums[i])
        return max_ 

思路二

贪心算法
其实思路和动态规划的差不多，但是原数组没有被破坏

class Solution:
    def maxSubArray(self, nums: 'List[int]') -> 'int':
        n = len(nums)
        curr_sum = max_sum = nums[0]
        for i in range(1, n):
            curr_sum = max(nums[i], curr_sum + nums[i])
            max_sum = max(max_sum, curr_sum)     
        return max_sum

思路三

分治法
时间复杂度O(nlogn)
空间复杂度O(logn)，递归时栈使用的空间。

class Solution:
    def cross_sum(self, nums, left, right, p): 
            if left == right:
                return nums[left]

            left_subsum = float('-inf')
            curr_sum = 0
            for i in range(p, left - 1, -1):
                curr_sum += nums[i]
                left_subsum = max(left_subsum, curr_sum)

            right_subsum = float('-inf')
            curr_sum = 0
            for i in range(p + 1, right + 1):
                curr_sum += nums[i]
                right_subsum = max(right_subsum, curr_sum)

            return left_subsum + right_subsum   
    
    def helper(self, nums, left, right): 
        if left == right:
            return nums[left]
        
        p = (left + right) // 2
            
        left_sum = self.helper(nums, left, p)
        right_sum = self.helper(nums, p + 1, right)
        cross_sum = self.cross_sum(nums, left, right, p)
        
        return max(left_sum, right_sum, cross_sum)
        
    def maxSubArray(self, nums: 'List[int]') -> 'int':
        return self.helper(nums, 0, len(nums) - 1)