Maximum Subarray

Maximum Subarray

原题链接：https://leetcode.com/problems/maximum-subarray/description/

题目很简单，给定一个数组，找出一个子数组使得它的和最大，也就是找出该数组的最大连续和。

Solution1: 采取分治法来解决这个问题，首先，将原数组划分为两个元素个数相等的子数组，然后递归求解。注意，递归求解只能找出完全位于数组左半部或者右半部的最大连续和，所以我们还要找出横跨左半部和右半部两个子数组的最大连续和，并和左半部以及右半部的最大连续和进行比较。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if (nums.size() == 1) return nums[0];

        int m = nums.size()/2;
        vector<int> SubArray_A(nums.begin(), nums.begin() + m);
        vector<int> SubArray_B(nums.begin() + m, nums.end());
        int largest_sum = max(maxSubArray(SubArray_A), maxSubArray(SubArray_B));

        int max_A = INT_MIN, max_B = INT_MIN, s = 0;
        for (int i = SubArray_A.size() - 1; i >=0; i--) {
            s += SubArray_A[i];
            max_A = max(s, max_A);
        }
        s = 0;
        for (int i = 0; i < SubArray_B.size(); i++) {
            s += SubArray_B[i];
            max_B = max(s, max_B);
        }

        largest_sum = max(largest_sum, max_A + max_B);
        return largest_sum;
    }
};

算法复杂度：当数组长度为n时，设T(n)为其时间复杂度，则有T(n) = 2T(n/2) + O(n), 所以，采用分治法，时间复杂度为O(nlogn)。

Solution2: 第一种方法的效率有点低，后来又改进了一下。
设置数组sum[n]来存储该序列的部分和，即sum[i]等于数组前i项的和。假设i < j，则sum[j] - sum[i]表示的就是我们要找的连续和，对于一个给定的j，要使sum[j] - sum[i]最大，那么，sum[i]就必须是最小的。所以，通过遍历数组sum，找出每一个sum[j]对应的最小的sum[i]就可以求解。

// Runtime: 9 ms
// Your runtime beats 42.89 % of cpp submissions.
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n = nums.size();

        int sum[n + 1];
        sum[0] = 0;
        for (int i = 0; i < n; i++) sum[i + 1] = sum[i] + nums[i];

        // largest sum = largest sum[i] - smallest sum[j], i > j
        int largest_sum = INT_MIN, smallest_sum_before_now = sum[0];
        for (int i = 1; i <= n; i++) {  
            largest_sum = (sum[i] - smallest_sum_before_now) > largest_sum ? (sum[i] - smallest_sum_before_now) : largest_sum;

            smallest_sum_before_now = (smallest_sum_before_now > sum[i]) ? sum[i] : smallest_sum_before_now;
        }

        return largest_sum;
    }
};

算法复杂度：只有一层循环，复杂度为O(n)。

Soluntion3: Idea is very simple. Basically, keep adding each integer to the sequence until the sum drops below 0.
If sum is negative, then should reset the sequence.

class Solution {
public:
    int maxSubArray(int A[], int n) {
        int ans=A[0],i,j,sum=0;
        for(i=0;i<n;i++){
            sum+=A[i];
            ans=max(sum,ans);
            sum=max(sum,0);
        }
        return ans;
    }
};

算法复杂度：O(n)