Leetcode Algorithms - Divide and Conquer : 53. Maximum Subarray

Description

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.

设计

这是一道Divide and Conquer类型的题目。使用分治法的话，可以将序列对半分为两个子序列，递归地在子序列中求最大连续和；求出子序列的最大连续和后，从序列的分界点分别向左和向右求出最大连续和并相加，将结果与子序列返回的最大连续和比较，即可得出解。
这种算法的复杂度递归方程是T(n)=2T(n/2)+O(n)，根据大师定理，T(n)=O(nlogn)。
题目提示有O(n)复杂度的算法。考虑先求出从序列首元素到后面每个元素的连续和，用数组储存起来。然后遍历该数组，记录当前遇到的最小的连续和，并计算数组当前下标的连续和减去遇到的最小连续和，大于之前的最大和的话，就替换最大和。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        initializeAnArrayForSavingContiguousSums(nums);
        calculateSumsOfContiguousSubarraysFromZeroToEveryIndex(nums);
        int maxSum = findMaxSumOfSubArrays();
        deleteTheArraySavingContiguousSums();
        return maxSum;
    }

private:
    int* contiguousSums;
    int size;

    void initializeAnArrayForSavingContiguousSums(vector<int>& nums) {
        size = nums.size();
        contiguousSums = new int[size];
    }

    void calculateSumsOfContiguousSubarraysFromZeroToEveryIndex(vector<int>& nums) {
        contiguousSums[0] = nums[0];
        for (int i = 1; i < size; i++)
            contiguousSums[i] = contiguousSums[i - 1] + nums[i];
    }

    int findMaxSumOfSubArrays() {
        int currentMinContiguousSum = 0;
        int maxSum = contiguousSums[0];
        for (int i = 0; i < size; i++) {
            if (maxSum < contiguousSums[i] - currentMinContiguousSum)
                maxSum = contiguousSums[i] - currentMinContiguousSum;
            if (currentMinContiguousSum > contiguousSums[i])
                currentMinContiguousSum = contiguousSums[i];
        }
        return maxSum;
    }

    void deleteTheArraySavingContiguousSums() {
        delete []contiguousSums;
        size = 0;
    }
};

分析

算法复杂度为O(n)。但是这种算法有点复杂，不够Leetcode该题讨论里的算法好。引用第2个解答：

this problem was discussed by Jon Bentley (Sep. 1984 Vol. 27 No. 9 Communications of the ACM P885)

the paragraph below was copied from his paper (with a little modifications)

algorithm that operates on arrays: it starts at the left end (element A[1]) and scans through to the right end (element A[n]), keeping track of the maximum sum subvector seen so far. The maximum is initially A[0]. Suppose we’ve solved the problem for A[1 … i - 1]; how can we extend that to A[1 … i]? The maximum
sum in the first I elements is either the maximum sum in the first i - 1 elements (which we’ll call MaxSoFar), or it is that of a subvector that ends in position i (which we’ll call MaxEndingHere).

MaxEndingHere is either A[i] plus the previous MaxEndingHere, or just A[i], whichever is larger.

public static int maxSubArray(int[] A) {
    int maxSoFar=A[0], maxEndingHere=A[0];
    for (int i=1;i<A.length;++i){
        maxEndingHere= Math.max(maxEndingHere+A[i],A[i]);
        maxSoFar=Math.max(maxSoFar, maxEndingHere); 
    }
    return maxSoFar;
}

第3和第4个解答也不错，不过我感觉还是这个解答精简干练，而且很好理解。