Leetcode Algorithms : 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个解答也不错，不过我感觉还是这个解答精简干练，而且很好理解。