最大子序和

leetcode 53

这道题刷了一遍还是不太熟练，总结一下几种解法；

方法一：动态规划
dp[i]表示以数组第i个元素结尾的最大子序列，很容易写出递推公式如下：
dp[i]=dp[i-1]>0?dp[i-1]+nums[i]:nums[i];
实现代码如下，比较简单的动态规划，空间复杂度可以优化为O(1)；

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

方法二：
贪心思想，其实就是将动态规划空间复杂度优化了一下，与上一种方法本质一样。
代码如下：

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

方法三：
分治的思想。要求一个数组的最大子序和，我们可以将其从中间切开，分为左右两个数组，当数组个数为1的时候显然可以直接得到最大子序和。问题复杂之处在于，数组整体最大子序列可能在左边数组，可能在右边数组，也可能横跨两个数组，关键在于如何处理第三种可能。
代码如下：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
       return help(nums,0,nums.size()-1); 
    }
    int help(vector<int>&v,int l,int r)
    {
        int mi=l+(r-l)/2;
        if(l>=r)return v[l];
        auto lsum=help(v,l,mi);
        auto rsum=help(v,mi+1,r);
        auto msum=findmaxsum(v,l,mi,r);
        return max(max(lsum,rsum),msum);
    }
    int findmaxsum(vector<int>&v,int l,int mi,int r)
    {
      int lmax=v[mi+1],rmax=v[mi],res1=lmax,res2=rmax;
      for(int i=mi+2;i<=r;++i)
      {
          if(v[i]<0)
              res1=max(res1,lmax);
          lmax+=v[i];
      }
     res1=max(lmax,res1);
        
    for(int i=mi-1;i>=l;--i)
    {
        if(v[i]<0)
                res2=max(res2,rmax);
        rmax+=v[i];
   }
        res2=max(rmax,res2);
        return res1+res2;
    }
};