【53. 最大子序和--最大子数组和】动态规划/分治算法

方法1：动态规划 

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int len=nums.size();
        int dp[100010]={0};
        dp[0]=nums[0];
        int maxx=dp[0];//不要写-1e8,因为dp[0]比它大
        for(int i=1;i<len;i++)
        {
            if(dp[i-1]<0)
            {
                dp[i]=nums[i];
            }
            else
            {
                dp[i]=dp[i-1]+nums[i];
            }
            if(dp[i]>maxx)
            {
                maxx=dp[i];
            }
        }
        return maxx;
    }
};

方法2：分治算法

class Solution {
public:
    struct Status {
        int lSum, rSum, mSum, iSum;
    };

    Status pushUp(Status l, Status r) {
        int iSum = l.iSum + r.iSum;
        int lSum = max(l.lSum, l.iSum + r.lSum);
        int rSum = max(r.rSum, r.iSum + l.rSum);
        int mSum = max(max(l.mSum, r.mSum), l.rSum + r.lSum);
        return (Status) {lSum, rSum, mSum, iSum};
    };

    Status get(vector<int> &a, int l, int r) {
        if (l == r) {
            return (Status) {a[l], a[l], a[l], a[l]};
        }
        int m = (l + r) >> 1;
        Status lSub = get(a, l, m);
        Status rSub = get(a, m + 1, r);
        return pushUp(lSub, rSub);
    }

    int maxSubArray(vector<int>& nums) {
        return get(nums, 0, nums.size() - 1).mSum;
    }
};