LeetCode之 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.

看到这个题第一反应是用一个二维数组表示数组A从第i到j之间的子数组的和，然后从中找出最大的，而且还要注意内存，因为数组较大，采用动态数组等可能会有memory limit之类的错误，因为数组较大，需要及时的delete，但是不幸还是发生了。。。。超时了。

思想如下：

                           

超时代码：

class Solution {
public:
    int maxSubArray(int A[], int n) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        
        int max = 0;
       
        int *sum[n];
        for (int i = 0; i < n ;i++){
            //sum[i] = new int[n];
        }
        
        
       // vector<vector<int>>sum;
        
        for(int i = 0 ;i < n;i++){
            sum[i] = new int[n];
        
            for(int j =i ;j<n;j++){
                if(i == j){
                    sum [i][j] = A[i];
                }
                else{
                     sum [i][j] = sum[i][j-1] + A[j];
                }
                if( max < sum[i][j] ){
                    max = sum[i][j];
                }
            } 
            delete sum[i];
        }
            
        return max;
        
    }
 
    
};

后来仔细想想，上述解法由于有大量的加法重复，超时正常，这个题完全可以用动态规划来做，思想如下；

1对于数组A[0]~A[i-1] (数组大小为n),其最大子数组的和肯定和A[0]~A[i-2](数组大小为i-1)这个子数组相关，这时需要考虑A[i-1]这个数：有两种情况：1）A[i-1]应该包含在最大子数组，2）不包含。这其中有一个非常重要的地方要注意：如果A[i]不能包含在最大子数组中，由于子数组是连续的，因此A[i]之后的数也不能包含在这个子数组中。

2.用max[i]来表示前i个数组成的数组的最大和，即从A[0]~A[i-1]的最大和，因此对于数组A[0]~A[i-1]而言，只要考虑两种情况：

        1）A[i-1]不包含，只需要考虑max[i-2]的情况即可；

        2）A[i-1]包含，也有两种情况：

               《1》max[i-2] + A[i-1] >  A[i-1] 把A[i-1]直接加入子数列，即子数列加入A[i-1]后，最大值能够增加, 此时max[i-1] =max[i-2] + A[i-1]

              《2》max[i-2] + A[i-1] <  A[i-1] （即前面的最大值是负数），子数列直接从A[i-1]开始，即前i个数的子数组最大和重新开始计算，为max[i-1] = A[i-1] 。

3 从上所知：max[i]其实是包含第i个元素的子数列的最大和 （关键！！！！！）因此，只需要考虑max这个数组中的最大值就可以了。。。。

示意图如下：

     

代码如下：

class Solution {
public:
    int maxSubArray(int A[], int n) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if(n==0) return 0;
        if(n==1) return A[0];
        
        int result=A[0];
        
        //max[i]代表有i元素的最大子数组的和
        int max[n];
        max[0] = A[0];
        for (int i = 1; i < n; ++i) {
            //判断加入A[i]后的子数列能够比A[i]大，
            //如果大，把该元素加入子数组，否则，新的字数从A[i]开始
            if(max[i-1] + A[i] >  A[i]){
                max[i] = max[i-1]+A[i];
            }
            else {
                max[i] = A[i];
            }
            //判断有i元素的最大子数组的和是否比原有的最大值大。。。
            if(max[i] > result){
                result = max[i];
            }
        }
        
        return result;
    }
};

续：想到几个例子，可以防止想错这个题，最基本的是100,2，-1   ；这个比较重要100，-1,100；

又仔细看了这个题，发现自己说的有点说不通，重新审视上述算法，这个算法叫Kadane算法，这个算法的精髓在这个地方：

如果有一个子数组的和是最大的，A[i....j]，那么对于任何k，这里i<=k<=j，这里的A[i...k]的和一定是非负的，否则最大子数组就把这块除去了。那么我们能得到这么一个想法：

把数组中所有满足上述条件的子数组（暂时称之为大数组）拿出来比较一下，谁的和最大，谁就是最大子数组。如何比较？

设m之前的子数组叫做A[m]的前缀，如果m的前缀非负，那么m和m的前缀组成的子数组就算是一个大数组，用这个大数组的和与一个maxSum比较一下，取较大的值就行了；如果m的前缀是负的，那么m和其前缀一定不能组成大数组了，好，我们把这个m单独放在一个大数组中，也和maxSum比一下。

这样的想法代码很简洁（48ms）：

class Solution {
public:
    int maxSubArray(int A[], int n) {
        int index = 0;
        int maxSum = A[index];
        int pre = A[index];
        for(int i=1;i<n;i++){
            //此时的pre是前i-1个元素的最大子数组和
            if(pre>0){
                pre+=A[i];
            }
            else{
                pre = A[i];
            }
            //此时的pre其实已经是包含了第i个元素的最大子数组和
            maxSum = max(maxSum,pre);
        }
        return maxSum;
    }
};