LeetCode_Simple_53. Maximum Subarray

2019.1.16

题目描述：

Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.

Example:

Input: [-2,1,-3,4,-1,2,1,-5,4],
Output: 6
Explanation: [4,-1,2,1] has the largest sum = 6.

Follow up:

If you have figured out the O(n) solution, try coding another solution using the divide and conquer approach, which is more subtle.

这是一道典型的动态规划问题，动态规划问题的关键在于写出状态转移方程和边界条件，我们用一个dp[i]记录以nums[i]为最后一个数的连续子序列的和，最大和就是dp[i]中的最大值

有两种情况：

1.这个最大和的连续序列只有一个元素，即从nums[i]开始，nums[i]结束，即dp[i]=nums[i]

2.这个最大和的连续序列只有一个元素，即从之前的某处开始，到nums[i]结束，即dp[i]=dp[i-1]+nums[i]

所以状态转移方程为：

dp[i]=max{dp[i-1]+nums[i],nums[i]}；

边界条件就是dp[0]，接着枚举i，即可得到整个dp数组，最后dp数组中的最大值即为最大和

解法一：动态规划

C++代码：

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

最后提出要用分治法来求，分治法的思想就类似于二分搜索法，我们需要把数组一分为二，分别找出左边和右边的最大子数组之和，然后还要从中间开始向左右分别扫描，求出的最大值分别和左右两边得出的最大值相比较取最大的那一个。

C++代码:

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if (nums.empty()) return 0;
        return helper(nums, 0, (int)nums.size() - 1);
    }
    int helper(vector<int>& nums, int left, int right) {
        if (left >= right) return nums[left];
        int mid = left + (right - left) / 2;
        int lmax = helper(nums, left, mid - 1);
        int rmax = helper(nums, mid + 1, right);
        int mmax = nums[mid], t = mmax;
        for (int i = mid - 1; i >= left; --i) {
            t += nums[i];
            mmax = max(mmax, t);
        }
        t = mmax;
        for (int i = mid + 1; i <= right; ++i) {
            t += nums[i];
            mmax = max(mmax, t);
        }
        return max(mmax, max(lmax, rmax));
    }
};