[leetcode] 53. Maximum Subarray

Question:

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.

Solution 1:

很简单的思路，从左往右遍历数组并相加，记录在sum里，如果相加结果为负则把sum置为0，因为负数加任何数都比0加这个数小。
即如果sum[i, j] < 0，则sum[i, j+1] < sum[j+1, j+1]
由于只需遍历一次，时间复杂度为O(n)，空间复杂度为O(1)。

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

            sum += nums[i];

            if (sum > max) {
                max = sum;
            }
        }
        return max;
    }
};

Solution 2：

由于题目还要求用分治的策略解题，就自然而然地把一个数组分成两个小数组，则原数组的最大子串就是下列三种情况之一：
a.分出来的左边数组的最大子串
b.分出来的右边数组的最大子串
c.跨越两个小数组的最大子串
一直以为找跨越两数组的最大子串会有更好的解法而不是直接从中间往两边扫描一遍，但最后没想到也没找到，导致超时。
由于每一次递归主要的工作是找跨越的最大子串，找最大子串只是简单地遍历了整个数组，分割成很多小数组后，每一层递归其实也要遍历整个数组，由于每次把数组一分为二，因此递归层数是logn，每一层遍历数组n，因此时间复杂度为O(nlogn)。
空间复杂度为O(1)。

// This solution would cause Time Limit Exceeded
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        return maxSubArrayRecursion(nums, 0, nums.size()-1);
    }

    int maxSubArrayRecursion(vector<int>& nums, int left, int right) {
        if (left == right) {
            return nums[left];
        }
        int mid = (left + right) / 2;
        int leftMax = maxSubArrayRecursion(nums, left, mid);
        int rightMax = maxSubArrayRecursion(nums, mid+1, right);

        int midLMax = nums[mid], midRMax = nums[mid+1], sum = 0;
        for (int i = mid; i >= 0; i--) {
            sum += nums[i];
            midLMax = max(sum, midLMax);
        }
        sum = 0;
        for (int i = mid+1; i < right; i++) {
            sum += nums[i];
            midRMax = max(sum, midRMax);
        }

        int ret = max(leftMax, rightMax);
        return max(ret, midLMax+midRMax);
    }
};