【leetcode】53 最大子序和（动态规划，分治）

题目链接：https://leetcode-cn.com/problems/maximum-subarray/

题目描述

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

示例:

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

进阶:

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

思路

动态规划

dp[i]表示以nums[i]结尾的最大子序和

复杂度分析
时间复杂度：O（n）
空间复杂度：O（n）

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if(nums.empty()) return 0;
        vector<int> dp(nums.size(), INT_MIN);   // dp[i]表示以nums[i]结尾的最大子序和
        dp[0] = nums[0];
        int maxSum = dp[0]; 
        for (int i = 1; i < nums.size(); ++i){
            dp[i] = dp[i-1] > 0? nums[i]+dp[i-1]: nums[i];
            maxSum = max(maxSum, dp[i]);
        }
        return maxSum;
    }
};

进一步优化空间效率，从O（n）降为O（1）

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

分治

最大子序和要么在左半边，要么在右半边，要么是穿过中间，对于左右边的序列，情况也是一样，因此可以用递归处理。中间部分的则可以直接计算出来

复杂度分析
时间复杂度：O(nlogn)
空间复杂度：O(1)

/*
 * 分治
 * 时间复杂度O(nlogn) 空间复杂度O(1)
 */
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if(nums.size() == 1) return nums[0];
        return help(nums,0,nums.size()-1);
    }

    int help(vector<int>& nums, int left, int right){
        if(left == right)
            return nums[left];
        if(left > right)
            return INT_MIN;
        int mid = (left+right)/2;
        int leftSum = help(nums,left,mid-1);
        int rightSum = help(nums,mid+1,right);

        // 计算穿过中间的最大子序和
        int midSumLeft = 0;     // 初始值为0 未选择任何左序列
        int midSumRight = 0;    
        int tmp = 0;
        for (int i = mid-1; i >= left; --i) {
            tmp += nums[i];
            midSumLeft = max(midSumLeft, tmp);
        }
        for (int i = mid+1,tmp = 0; i <= right ; ++i) {
            tmp += nums[i];
            midSumRight = max(midSumRight, tmp);
        }

        return max(max(leftSum,rightSum), midSumLeft+midSumRight+nums[mid]);
    }
};