leetcode | Maximum Subarray 最大连续子序列的和

Maximum Subarray： https://leetcode.com/problems/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.

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

contiguous 连续的

解析：

1. 动态规划法

当从头遍历数组元素时，对于数组中的一个整数有几种选择呢？
两种：加入之前的subArray；自己另起一个新的subArray.那么时候会出现这两种状况：
- 当之前subArray 的总和大于 0 时，我们认为 其对后续结果是有贡献的，这种情况下，我们选择加入之前的subArray
- 当之前subArray 的总和小于等于0时，我们认为其对后续结果是没有贡献的，这种情况下，我们选择以当前数字开始，另起一个subArray

设状态f(j) 表示 以 nums[j] 为结尾的最大连续子序列的和，则状态转移方程如下：
f(j) = max{f(j)+nums[j], nums[j]},其中1<=j<=n
target = max{f(j)}, 其中1<=j<=n

class Solution {
public:
    // 时间复杂度 O(n)
    int maxSubArray(vector<int>& nums) {
        int result = INT_MIN;
        int sum = 0;
        for (int i = 0; i < nums.size(); i++) {
            sum = max(sum+nums[i], nums[i]);
            result = max(result, sum);
        }
        return result;
    }
};

2. 分治法

最大连续子序列可能存在的三个区间：
1. 完全在nums[left, mid-1]
2. 完全在nums[mid+1, right]
3. 包含 nums[mid],然后向左右扩展
最后比较左子序列、右子序列和中间序列，得到最大和。

class Solution {
public:
    // 时间复杂度O(nlogn)
    int maxSubArray(vector<int>& nums) {
       return divide(nums, 0, nums.size()-1);
    }
private:
    int divide(vector<int>& nums, int left, int right) {
        if (left == right)
            return nums[left];
        if (left+1 == right)
            return max(nums[left]+nums[right], max(nums[left], nums[right]));
        int mid = (left+right)/2;
        int left_max = divide(nums, left, mid-1);
        int right_max = divide(nums, mid+1, right);
        // 求中间连续子序列的最大和
        int mid_max = nums[mid]; 
        // 向左扩展
        int temp = mid_max;
        for (int i = mid-1; i >= left; i--) {
            temp += nums[i];
            mid_max = max(temp, mid_max);
        }
        // 向右扩展
        temp = mid_max;
        for (int j = mid+1; j <= right; j++) {
            temp += nums[j];
            mid_max = max(temp, mid_max);
        }
        return max(mid_max, max(left_max, right_max));
    }
};

参考：
https://github.com/soulmachine/leetcode
http://blog.csdn.net/xshengh/article/details/12708291