最大子序列和

分治

思路：最大子序列和可能出现的地方

1. 左半部分
2. 右半部分
3. 跨越中间的部分

所以我们可把问题分成对左右半部分进行递归求解，然后再将二者合并考虑即考虑中间部分，最后求出它们之间的最大值

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int length=nums.size();
        return maxSubSum(nums,0,length-1);
    }

    int maxSubSum(vector<int>& nums,int left,int right)
    {
        int MaxLeftSum,MaxRightSum;
        int MaxLeftBorderSum,MaxRightBorderSum;
        int LeftBorderSum,RightBorderSum;
        int Center,i;

        if(left==right)
        {
            return nums[left];
        }

        Center=(left+right)/2;
        MaxLeftSum=maxSubSum(nums,left,Center);
        MaxRightSum=maxSubSum(nums,Center+1,right);

        MaxLeftBorderSum=INT_MIN;LeftBorderSum=0;
        for(i=Center;i>=0;--i)
        {
            LeftBorderSum+=nums[i];
            if(LeftBorderSum>MaxLeftBorderSum)
                MaxLeftBorderSum=LeftBorderSum;
        }

        MaxRightBorderSum=INT_MIN;RightBorderSum=0;
        for(i=Center+1;i<=right;++i)
        {
            RightBorderSum+=nums[i];
            if(RightBorderSum>MaxRightBorderSum)
                MaxRightBorderSum=RightBorderSum;
        }
        return max(max(MaxLeftSum,MaxRightSum),MaxRightBorderSum+MaxLeftBorderSum);
    }
};

不过在leetcode上时间会超出限制，因为并不是O(N),而是O(NlogN)

动态规划法

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int MaxSubSum=nums[0];
        for(int i=1;i<nums.size();++i)
        {
            if(nums[i-1]>0)
            {
                nums[i]+=nums[i-1];
            }
            MaxSubSum=max(nums[i],MaxSubSum);
        }
        return MaxSubSum;
    }

};

同样也是将问题分解，我们考虑两个数的情况；若第一个数的值小于0，那最后一个数不论是多少，加上之后都会减小，所以当遇到这种情况时不进行处理；相反，但前一个数大于0时，相加即可。
根据推论，我们就可以通过修改数组跟踪当前位置的最大值，在直到当前位置最大和后更新全局最大和。