[leetcode]Maximum Subarray

Find the contiguous subarray within an array (containing at least one number) which has the largest sum.

For example, given the array [−2,1,−3,4,−1,2,1,−5,4],
the contiguous subarray [4,−1,2,1] has the largest sum = 6.

这是一个经典问题，求一个数组最大子数组，本题处理的是一维数组的情况，处理这个问题一个比较好的O(n)算法是kadane算法，代码如下：

    int maxSubArray(vector<int>& nums) {

        int len=nums.size();
        if(len==0){
            return 0;
        }
        int max_so_far=nums[0];
        int max_ending_here=nums[0];
        for(int i=1;i<len;++i){
            max_ending_here=max(nums[i],max_ending_here+nums[i]);
            max_so_far=max(max_so_far,max_ending_here);
        }
        return max_so_far;
    }

由于此算法使用了最佳子结构，所以可以看作是一个动态规划问题。和常见动态规划问题比，我们没有记录下所有位置作为终点的子数组的最大子数列值得数组，因为我们只需要知道最大值。同时，我们没有维护子数列的前后指针，因为位置信息对于求解最大值没有贡献，我们只需要遍历一遍数组即可。对于终点为n的子数列，我们不需要知道他的最大子数列从何处开始（尽管我们可以做到）。
这个题目看起来并不是动态规划问题，因为他不具备常见动态规划问题的特征，我们只需要上一步的最优解，不需要记录全部子问题最优解。全局最优解需要用到局部最优解，一旦找到这样的结构，我们就可以尝试这一题这种思路。
这一题还可以用分治法来做，就不解释了，直接上代码：

int divide(vector<int>&nums,int l,int r){
    if(l==r)
        return nums[l];
    if((r-l)==1){
        return max(nums[l]+nums[r],max(nums[l],nums[r]));
        }
    int mid=(l+r)/2;
    int lmax=divide(nums,l,mid-1);
    int rmax=divide(nums,mid+1,r);
    int mmax=nums[mid];
    int tmp=mmax;
    for(int i=mid-1;i>=l;--i){
        tmp+=nums[i];
        if(tmp>mmax){
            mmax=tmp;
        }
    }
    tmp=mmax;
    for(int j=mid+1;j<=r;++j){
        tmp+=nums[j];
        if(tmp>mmax){
            mmax=tmp;
        }
    }
    return max(mmax,max(lmax,rmax));
}   
int maxSubArray(vector<int> &nums){
    int len=nums.size();
    if(len==0)
        return 0;
    return divide(nums,0,len-1);
}

分治法的时间复杂度仍然是O(n）,因为也要对数组进行一次遍历。