leetcode记录——53、最大子序和

题目如下：

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

示例 1：

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

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

输入：nums = [0]
输出：0
示例 4：

输入：nums = [-1]
输出：-1
示例 5：

输入：nums = [-100000]
输出：-100000

———————————————————————————————————————————

思路如下：虽然说有暴力法应该首选暴力法，但这种子序列的题目，其实（个人感觉）关键在于下一步的数字，取或不取，因此可以用动态规划来做。如果下一步的数+当前的和<当前和，那么下一步的数字可以不取得，遍历全部数组，再返回记录max的变量即可。

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

                

 通过没问题，但这个耗时和内存都有些太高了，因此对此进行优化。其实优化思路，是将temp数组去除，用O（1）级变量进行，这样整体时间和内存应该都可以减低。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int ans=nums[0],temp=0;
        for(auto x:nums){
            temp=max(temp+x,x);
            ans=max(ans,temp);
        }
        return ans;
    }
};

这。。。看起来好像优化了，，但为啥最后没有下降太多啊               

                

 算了优化成功就行，明天试试分治

_____________________________________________________________________________

分治法思路：把数组进行拆分left，mid，right，那么最大子序列=（left到mid部分最大子序列，mid为中心的最大子序列，mid+1到right的最大子序列）。因此，我们便可以对数组使用分治进行处理

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int numslen=nums.size();
        return helper(0, numslen-1, nums);
    }
    int helper(int left,int right,vector<int>& nums){
        if(left==right) return nums[left];
        int mid=left+(right-left)/2;
        int leftAns=helper(left,mid, nums);
        int rightAns=helper(mid+1,right, nums);
        int midAns=crossHelper(left, right, mid, nums);
        return max(max(leftAns,rightAns),midAns);
    }
    int crossHelper(int left,int right,int mid,vector<int>& nums){
        int temp1=INT_MIN;
        int temp=0;//暂时记录和
        for(int i=mid;i>=left;i--){
            temp+=nums[i];
            temp1=max(temp1,temp);
        }
        int temp2=INT_MIN;
        temp=0;//重新初始化
        for(int i=mid+1;i<=right;i++){
            temp+=nums[i];
            temp2=max(temp2,temp);
        }
        return (temp1+temp2);
    }
};

但整体的时间复杂度，不理想，与dp相比，还是dp更为简单快捷

        ​​​​​​​        ​​​​​​​