3.16【leetcode练习】最大子数组和

最大子数组和

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

子数组 是数组中的一个连续部分。

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

示例 2：
输入：nums = [1]
输出：1

示例 3：
输入：nums = [5,4,-1,7,8]
输出：23

提示：

• 1 <= nums.length <= $10^5$
• $-10^4$ <= nums[i] <= $10^4$

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

1. 暴力求解（这个时间复杂度高了 没过…）

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

2. 动态规划
   想象一个很长的数组，一旦连续几个数的和都小于0，后面再加任何数都会比当前的数要小，因此当几个数的和为0时，将前面的数据置0即可。
   递归式为：
   $$b[j]=\{\begin{array}{ll}0& j=0\\ \max \{b[j-1]+a[j],a[j]\}& 1⩽j⩽n\end{array}$$
   （我的这串代码两个if的顺序不能换，不然对于单负数的数组会错误）

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

3. 分治法
   这个方法时间没过应该是递归的问题…

class Solution {
public:
    int maxSubArrayDivide(vector<int>& nums, int l, int r){
        int sum=0;
        int max;
        if (l==r) return nums[l]; //递归出口
        else{
            int center = (l+r)/2;
            int leftsum=maxSubArrayDivide(nums,l,center);
            int rightsum=maxSubArrayDivide(nums,center+1,r);
            int centersum;
            int clsum=0,crsum=0;
            int clmax=nums[center],crmax=nums[center+1];
            for (int i=center;i>=0;i--){
                clsum+=nums[i];
                if (clmax<clsum) clmax=clsum;
            }
            for (int i=center+1;i<=r;i++){
                crsum+=nums[i];
                if (crmax<crsum) crmax=crsum; 
            }
            centersum=clmax+crmax;
            if (centersum<leftsum) max=leftsum;
            else max=centersum;
            if (max<rightsum) max=rightsum;
        }
        return max;
    }
    int maxSubArray(vector<int>& nums) {
        return maxSubArrayDivide(nums, 0, nums.size()-1);
    }
};