LeetCode.53. 最大子序和

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

示例:

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

如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。

利用分治算法求解最大子数组的问题

参考算法导论第4章

思路：如果我们要寻找子数组A[low,…high]的最大子数组。我们将数组分成两个同等规模的子数组。A[low,…,mid],A[mid+1,…high]。
现在，最大子数组A[i,j]必然处于以下三种情况之一：

• 完全位于子数组A[low,mid].
• 完全位于子数组A[mid+1.high].
• 跨越了中点，因此$low\le i\le mid\le j\le high$.
  我们开始最大子数组跨越了终点的情况。下面给出跨越了中点的最大子数组算法。

def findMaxCrossingSubarray(A,low,mid,high):
    left_sum = -float('inf')
    sumnum = 0
    for i in range(mid,low-1,-1):
        sumnum = sumnum + A[i]
        if sumnum >  left_sum:
            left_sum = sumnum
            max_left = i      # 求出A[low,..mid]最大子数组A[i,..mid]的索引i
    right_sum = -float('inf')
    sumnum = 0
    for j in range(mid+1,high+1):
        sumnum = sumnum + A[j]
        if sumnum > right_sum:
            right_sum = sumnum
            max_right = j   # 求出A[mid+1,..high]最大子数组A[mid+1,j]的索引j
    return max_left,max_right,left_sum+right_sum

def findmaxsubarray(A,low,high):
            if high < low:
                return []
            elif high == low:
                return (low,high,A[low])    #如果只有一个元素就返回这个元素
            else:
                mid = int((low+high)/2)
                (left_low,left_high,left_sum) = findmaxsubarray(A,low,mid)   # 计算 A[low,mid]的最大子数组
                (left_low,right_high,right_sum) = findmaxsubarray(A,mid+1,high) # 计算A[mid+1, high]的最大子数组
                cross_low,cross_high,cross_sum = findmaxcrossingsubarray(A,low,mid,high) # 计算跨越中点的最大子数组
                if left_sum >= right_sum and left_sum >= cross_sum:   # 比较之后返回最大的
                    return (left_low,left_high,left_sum)
                elif right_sum >= left_sum and right_sum >= cross_sum:
                    return (right_sum,right_high,right_sum)
                else:
                    return cross_low,cross_high,cross_sum

#完整算法
class Solution:
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        def findmaxsubarray(A,low,high):
            if high < low:
                return []
            elif high == low:
                return (low,high,A[low])
            else:
                mid = int((low+high)/2)
                (left_low,left_high,left_sum) = findmaxsubarray(A,low,mid)
                (left_low,right_high,right_sum) = findmaxsubarray(A,mid+1,high)
                cross_low,cross_high,cross_sum = findmaxcrossingsubarray(A,low,mid,high)
                if left_sum >= right_sum and left_sum >= cross_sum:
                    return (left_low,left_high,left_sum)
                elif right_sum >= left_sum and right_sum >= cross_sum:
                    return (right_sum,right_high,right_sum)
                else:
                    return cross_low,cross_high,cross_sum

        def findmaxcrossingsubarray(A,low,mid,high):
            left_sum = -float('inf')
            sumnum = 0
            for i in range(mid,low-1,-1):
                sumnum = sumnum + A[i]
                if sumnum >  left_sum:
                    left_sum = sumnum
                    max_left = i
            right_sum = -float('inf')
            sumnum = 0
            for j in range(mid+1,high+1):
                sumnum = sumnum + A[j]
                if sumnum > right_sum:
                    right_sum = sumnum
                    max_right = j
            return max_left,max_right,left_sum+right_sum
        return findmaxsubarray(nums,0,len(nums)-1)[-1]

利用动态规划的思想：

基于算法导论练习题4.1-5给出的思想：
若已知A[1…j]的最大子数组，基于如下性质将将拓展为A[1,j+1]的最大子数组：A[1…j+1]的最大子数组要么是A[1…j]的最大子数组，要么是某个子数组A[i,…j+1]。我们可以找到子问题即A[1]的最大子数组为A[1]。
我们用global[j]表示A[1…j]的最大子数组。
用local[j+1]表示最大子数组A[i,…j+1]。(即这个最大子数组必须包含A[j+1].)
我们可以写出子问题和递归式：

子问题：
$$local[1]=A[1];global[1]=A[1]$$

递归式：
$$\begin{gathered} local[j+1]=max(local[j]+A[j+1],A[j+1]) \\ global[i+1]=max(global[i],local[j+1]) \end{gathered}$$

class Solution:
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) < 1:
            return 0
        globaln = nums[0]
        local = nums[0]
        for i in range(1,len(nums)):
            local = max(nums[i],local+nums[i])
            globaln = max(local,globaln)
        return globaln