分治法/动态规划-最大子序和

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

示例:

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

分治法【时间复杂度O(NlogN)】

概括来说，就是把数组分成两个序列，最大和子序列要么在左半部分，要么在右半部分，要么是横跨左右部分，也就是说包含左半部分的最后一个元素和右半部分的第一个元素。在求左半部分或者右半部分时又再次将序列拆分，如此循环。

 * 拆分序列（直到只剩下一个数的序列） ---->   左序列|右序列
 * 求左序列最大值
 * 求右序列最大值
 * 求跨边界的最大值
 * 求以上三个最大值的最大值
 * 不断重复

举个栗子：

 * 假定存在以下序列
 * {4 -3 5 -2}
 * 
 * 做拆分
 * {4 -3}{5 -2}
 * 做拆分
 * {4}{-3}
 * 做拆分
 * {4}  求得当前序列最大和为【4】
 * 处理右边的{-3}
 * {-3}小于0，所以返回0，则最大和为【0】
 * 还有一种就是横跨左右序列的-3+4=【1】
 * 它们被拆分之前是{4 -3}，所以{4 -3}的最大和是max{4,0,1}=【4】
 * 处理右边的
 * {5 -2}
 * 做拆分
 * {5}{-2}
 * 做拆分
 * {5}  求得序列最大和为【5】
 * 处理右边的{-2}
 * {-2}小于0，所以返回0，最大和为【0】
 * 还有一种就是横跨左右序列的-2+5=【3】
 * 它们被拆分前是{5 -2}，所以{5 -2}最大和是max{5,0,3}=【5】
 * {4 -3}{5 -2}处理完毕，最大和分别是【4】【5】
 * ------------------------------------------------------------
 * 它们被拆分之前是{4 -3 | 5 -2}
 * 先说结果：
 *      左边的最大和（4 + （-3）） = 1
 *      右边的最大和5
 *      左右相加得【6】
 *
 * 为什么是左边4+(-3)呢？
 * 首先以|为边界向左扫描求最大和
 * 因为是从【中间向左】扫，第一个扫到的数是-3
 * 再向左扫，是4，4比-3绝对值大吧！
 * 要包含4，就必须把-3加上
 * 因为要跨越边界，-3肯定要经过的，才能形成连续的序列。
 * 左边扫描完了，就从【中间向右】扫
 * 第一个发现5，扫向下一个，发现是-2，相加起来还不如一个5呢
 * 于是就不要-2了。为什么可以不要？因为这是一个从左往右的序列~
 * 而-2在最右边，当然是可以抛弃的了。
 *
 * 如果-2 后面还有一个数，比如3的话，是{5 -2 3}，这时把三个数加起来是6，比5大，就需要把三个数都包含起来。
 * 因为三个数加起来比5大恩。就是这个理。
 *
 * 此时可以知道{4 -3 | 5 -2}，最大和是左边的1加上右边的5得到max{4,6,5}=【6】。

采用c++代码实现

//求三个数中的最大值
int max3(int a,int b,int c)
{
    return a>b?(a>c?a:c):(b>c?b:c);
}

int maxsubarr(vector<int> &nums,int left,int right){
    //定义 左右端最大值
    int maxleft=0,maxright=0;
    //定义左右端边界值
    int leftborder=0,rightborder=0;
    //定义左右端边界最大值
    int maxleftborder=0,maxrightborder=0;
    //递归出口，只剩一个数时
    if(left==right)
        return nums[left]>0?nums[left]:0;

    int mid=(left+right)/2;
    //左边递归
    maxleft = maxsubarr(nums,left,mid);
    //右边递归
    maxright = maxsubarr(nums, mid+1, right);
    //求左边届最大值
    for(int i=mid;i>=left;i--){
        leftborder+=nums[i];
        if(leftborder>maxleftborder)
            maxleftborder=leftborder;
    }
    //求右边届最大值
    for(int i=mid+1;i<=right;i++){
        rightborder+=nums[i];
        if(rightborder>maxrightborder)
            maxrightborder=rightborder;
    }
    return max3(maxleft,maxright,maxleftborder+maxrightborder);
}

int maxSubArr(vector<int>nums){
    return maxsubarr(nums, 0, (int)nums.size()-1);
}

动态规划【时间复杂度O(N)】

步骤 1：令状态 dp[i] 表示以 A[i] 作为末尾的连续序列的最大和（这里是说 A[i] 必须作为连续序列的末尾）。

步骤 2：做如下考虑：因为 dp[i] 要求是必须以 A[i] 结尾的连续序列，那么只有两种情况：

• 这个最大和的连续序列只有一个元素，即以 A[i] 开始，以 A[i] 结尾。
• 这个最大和的连续序列有多个元素，即从前面某处 A[p] 开始 ，一直到 A[i] 结尾
• 对第一种情况，最大和就是 A[i] 本身，对第二种情况，最大和是 dp[i-1]+A[i]。

于是得到状态转移方程：

　　　　　　　　

$$dp[i] = max{A[i], dp[i-1]+A[i]}$$
这个式子只和 i 与 i 之前的元素有关，且边界为 dp[0] = A[0]，由此从小到大枚举 i，即可得到整个 dp 数组。接着输出 dp[0]，dp[1]，…，dp[n-1] 中的最大子即为最大连续子序列的和。

采用c++代码实现

int maxSubArray(vector<int>& nums) {
    int maxsum=0;
    int *dp =new int[nums.size()];
    dp[0]=nums[0];
    maxsum=dp[0];
    for(int i=1;i<nums.size();i++){
        dp[i]=nums[i]+(dp[i-1]>0?dp[i-1]:0);
        maxsum=maxsum>dp[i]?maxsum:dp[i];
    }
    return maxsum;
}