算法--三种方法求连续子数组的最大和

爱被打了一巴掌 2022-06-14 02:27 171阅读 0赞

这是一道考的烂的不能再烂的题目，但是依然有很多公司乐于将这样的题目作为笔试或面试题，足见其经典。

# **题目描述：** #

输入一个整形数组，数组里有正数也有负数。
    数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。
    求所有子数组的和的最大值。要求时间复杂度为O(n)。
    
    例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2，
    因此输出为该子数组的和18。

下面按照时间复杂度逐步优化的顺序依次给出这三种算法。

# **暴力求解法** #

该方法的思想非常简单，先找出从第1个元素开始的最大子数组，而后再从第2个元素开始找出从第2个元素开始的最大子数组，依次类推，比较得出最大的子数组。实现代码如下：

/*
    常规方法,时间复杂度O（n*n）
    先从第一个元素开始向后累加，
    每次累加后与之前的和比较，保留最大值，
    再从第二个元素开始向后累加，以此类推。
    */
    int MaxSubSum1(int *arr,int len)
    {
        int i,j;
        int MaxSum = 0;
        //每次开始累加的起始位置的循环
        for(i=0;i<len;i++)
        {
            int CurSum = 0;
            //向后累加的循环
            for(j=i;j<len;j++)
            {
                CurSum += arr[j];
                if(CurSum > MaxSum)
                    MaxSum = CurSum;
            }
        }
        return MaxSum;
    }

很明显地可以看出，该方法的时间复杂度为O（n\*n）。

# **分治求解法** #

## **解释一** ##

考虑将数组从中间分为两个子数组，则最大子数组必然出现在以下三种情况之一：

1、完全位于左边的数组中。
    
    2、完全位于右边的数组中。
    
    3、跨越中点，包含左右数组中靠近中点的部分。
    
    递归将左右子数组再分别分成两个数组，直到子数组中只含有一个元素，退出每层递归前，返回上面三种情况中的最大值。实现代码如下：

/*
    求三个数中的最大值
    */
    int Max3(int a,int b,int c)
    {
        int Max = a;
        if(b > Max)
            Max = b;
        if(c > Max)
            Max = c;
        return Max;
    }
    
    /*
    次优算法，采用分治策略
    */
    int MaxSubSum2(int *arr,int left,int right)
    {
        int MaxLeftSum,MaxRightSum; //左右边的最大和
        int MaxLeftBorderSum,MaxRightBorderSum; //含中间边界的左右部分最大和
        int LeftBorderSum,RightBorderSum;   //含中间边界的左右部分当前和
        int i,center;
    
        //递归到最后的基本情况
        if(left == right)
            if(arr[left]>0)
                return arr[left];
            else
                return 0;
    
        //求含中间边界的左右部分的最大值
        center = (left + right)/2;
        MaxLeftBorderSum = 0;
        LeftBorderSum = 0;
        for(i=center;i>=left;i--)
        {
            LeftBorderSum += arr[i];
            if(LeftBorderSum > MaxLeftBorderSum)
                MaxLeftBorderSum = LeftBorderSum;
        }
        MaxRightBorderSum = 0;
        RightBorderSum = 0;
        for(i=center+1;i<=right;i++)
        {
            RightBorderSum += arr[i];
            if(RightBorderSum > MaxRightBorderSum)
                MaxRightBorderSum = RightBorderSum;
        }
    
        //递归求左右部分最大值
        MaxLeftSum = MaxSubSum2(arr,left,center);
        MaxRightSum = MaxSubSum2(arr,center+1,right);
    
        //返回三者中的最大值
        return Max3(MaxLeftSum,MaxRightSum,MaxLeftBorderSum+MaxRightBorderSum);
    }
    
    /*
    将分支策略实现的算法封装起来
    */
    int MaxSubSum2_1(int *arr,int len)
    {
        return MaxSubSum2(arr,0,len-1);
    }

设该算法的时间复杂度为T（n）,则：

T（n）= 2T（n/2）+ O（n），且T（1）= 1。

逐步递推得到时间复杂度T（n）= O（nlogn）。

--------------------

## **另一种通俗解释二** ##

这里再介绍一种更高效的算法，时间复杂度为O(nlogn)。这是个分治的思想，解决复杂问题我们经常使用的一种思维方法——分而治之。  
而对于此题，我们把数组A\[1..n\]分成两个相等大小的块：

A[1..n/2]和A[n/2+1..n]，最大的子数组只可能出现在三种情况：
    
    A[1..n]的最大子数组和A[1..n/2]最大子数组相同；
    A[1..n]的最大子数组和A[n/2+1..n]最大子数组相同；
    A[1..n]的最大子数组跨过A[1..n/2]和A[n/2+1..n]

前两种情况的求法和整体的求法是一样的，因此递归求得。

第三种，我们可以采取的方法也比较简单，沿着第n/2向左搜索，直到左边界，找到最大的和maxleft，以及沿着第n/2+1向右搜索找到最大和maxright，那么总的最大和就是maxleft+maxright。而数组A的最大子数组和就是这三种情况中最大的一个。

**伪代码**

int maxSubArray(int *A,int l,int r) {
        if l<r do 
            mid = (l+r)/2;
            ml = maxSubArray(A,l,mid); //分治 
            mr = maxSubArray(A,mid+1,r);
            for i=mid downto l do 
                search maxleft; 
            for i=mid+1 to r do 
                search maxright; 
            return max(ml,mr,maxleft+maxright); //归并 
            then //递归出口 
                return A[l]; 
    }

--------------------

# **线性时间算法** #

该算法在每次元素累加和小于0时，从下一个元素重新开始累加。实现代码如下：

/*
    最优方法，时间复杂度O（n）
    和最大的子序列的第一个元素肯定是正数
    因为元素有正有负，因此子序列的最大和一定大于0
    */
    int MaxSubSum3(int *arr,int len)
    {
        int i;
        int MaxSum = 0;
        int CurSum = 0;
        for(i=0;i<len;i++)
        {
            CurSum += arr[i];
            if(CurSum > MaxSum)
                MaxSum = CurSum;
            //如果累加和出现小于0的情况，
            //则和最大的子序列肯定不可能包含前面的元素，
            //这时将累加和置0，从下个元素重新开始累加
            if(CurSum < 0)
                CurSum = 0;
        }
        return MaxSum;
    }

显然，该算法的时间复杂度O（n）。该算法理解起来应该不难，但是要想出来可就不容易了。另外，该算法的一个附带的有点是：它只对数据进行一次扫描，一旦元素被读入并被处理，它就不再需要被记忆。因此，如果数组在磁盘或磁带上，他就可以被顺序读入，在主存中不必存储数组的任何部分。不仅如此，在任意时刻，该算法都能对它已经读入的数据给出最大子数组（另外两种算法不具有这种特性）。具有这种特性的算法叫做联机算法。

# **扫描法** #

**扫描算法实际上就是上面的线性时间算法，这里是转载的自另一个作者，思路逻辑可能更加严谨一些，分析也更加精确。**

当我们加上一个正数时，和会增加；当我们加上一个负数时，和会减少。如果当前得到的和是个负数，那么这个和在接下来的累加中应该抛弃并重新清零，不然的话这个负数将会减少接下来的和。实现：

> （后加注：这里提到的扫描法存在一个问题就是如果最大字段和小于0则算法没法给出正确答案。其实这个问题用动态规划就好，这里的扫描法其实真的不是个好方法，只是因为很有名所以还是粘出来了）

//copyright@ July 2010/10/18  
    //updated，2011.05.25.  
    #include <iostream.h>  
    
    int maxSum(int* a, int n)  
    {  
        int sum=0;  
        //其实要处理全是负数的情况，很简单，如稍后下面第3点所见，直接把这句改成："int sum=a[0]"即可  
        //也可以不改，当全是负数的情况，直接返回0，也不见得不行。  
        int b=0;  
    
        for(int i=0; i<n; i++)  
        {  
            if(b<0)           //...  
                b=a[i];  
            else  
                b+=a[i];  
            if(sum<b)  
                sum=b;  
        }  
        return sum;  
    }  
    
    int main()  
    {  
        int a[10]={
       1, -2, 3, 10, -4, 7, 2, -5};  
        //int a[]={-1,-2,-3,-4};  //测试全是负数的用例  
        cout<<maxSum(a,8)<<endl;  
        return 0;  
    }  
    
    /*------------------------------------- 
    解释下： 
    例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5， 
    那么最大的子数组为3, 10, -4, 7, 2， 
    因此输出为该子数组的和18。 
    
    所有的东西都在以下俩行， 
    即： 
    b  ：  0  1  -1  3  13   9  16  18  13   
    sum：  0  1   1  3  13  13  16  18  18 
    
    其实算法很简单，当前面的几个数，加起来后，b<0后， 
    把b重新赋值，置为下一个元素，b=a[i]。 
    当b>sum，则更新sum=b; 
    若b<sum，则sum保持原值，不更新。。July、10/31。

（后加注：前面的代码是粘贴别人的，下面的证明是我自己鼓捣的。之后由于看到了动态规划法，觉得这个证明实在是没什么必要看了。在后来练习了很多数学证明发现，证明是越精炼越好，不过这种敢于穷举情况的思路还是很好的，很多时候难的证明题只要多穷举几种情况再加以精炼往往就能做出，大不了多举几个情况问题也能解决）

据说这道题是《编程珠机》里面的题目，叫做扫描法，速度最快，扫描一次就求出结果，复杂度是O（n）。书中说，这个算法是一个统计学家提出的。

这个算法如此精炼简单，而且复杂度只有线性。但是我想，能想出来却非常困难，而且证明也不简单。在这里，我斗胆写出自己证明的想法：

关于这道题的证明，我的思路是去证明这样的扫描法包含了所有n^2种情况，即所有未显示列出的子数组都可以在本题的扫描过程中被抛弃。

1 首先，假设算法扫描到某个地方时，始终未出现加和小于等于0的情况。

我们可以把所有子数组（实际上为当前扫描过的元素所组成的子数组）列为三种：

1.1 以开头元素为开头，结尾为任一的子数组

1.2 以结尾元素为结尾，开头为任一的子数组

1.3 开头和结尾都不等于当前开头结尾的所有子数组

1.1由于遍历过程中已经扫描，所以算法已经考虑了。1.2确实没考虑，但我们随便找到1.2中的某一个数组，可知，从开头元素到这个1.2中的数组的加和大于0（因为如果小于0就说明扫描过程中遇到小于0的情况，不包括在大前提1之内），那么这个和一定小于从开头到这个1.2数组结尾的和。故此种情况可舍弃

1.3 可以以1.2同样的方法证明，因为我们的结尾已经列举了所有的情况，那么每一种情况和1.2是相同的，故也可以舍弃。

2 如果当前加和出现小于等于0的情况，且是第一次出现，可知前面所有的情况加和都不为0

一个很直观的结论是，如果子段和小于0，我们可以抛弃，但问题是是不是他的所有以此子段结尾为结尾而开头任意的子段也需要抛弃呢？

答案是肯定的。因为以此子段开头为开头而结尾任意的子段加和都大于0（情况2的前提），所以这些子段的和是小于当前子段的，也就是小于0的，对于后面也是需要抛弃的。也就是说，所有以之前的所有元素为开头而以当前结尾之后元素为结尾的数组都可以抛弃了。

而对于后面抛弃后的数组，则可以同样递归地用1 2两个大情况进行分析，于是得证。

这个算法的证明有些复杂，现在感觉应该不会错，至少思路是对的，谁帮着在表达上优化下吧。:-)

# **动态规划** #

设sum\[i\]为以第i个元素结尾且和最大的连续子数组。假设对于元素i，所有以它前面的元素结尾的子数组的长度都已经求得，那么以第i个元素结尾且和最大的连续子数组实际上，要么是以第i-1个元素结尾且和最大的连续子数组加上这个元素，要么是只包含第i个元素，即sum\[i\] = max(sum\[i-1\] + a\[i\], a\[i\])。可以通过判断sum\[i-1\] + a\[i\]是否大于a\[i\]来做选择，而这实际上等价于判断sum\[i-1\]是否大于0。由于每次运算只需要前一次的结果，因此并不需要像普通的动态规划那样保留之前所有的计算结果，只需要保留上一次的即可，因此算法的时间和空间复杂度都很小。

**伪代码**

result = a[1]
    sum = a[1]
    
    for i: 2 to LENGTH[a]
      if sum > 0
        sum += a[i]
      else
        sum = a[i]
    
      if sum > result
        result = sum
    
    return result

--------------------

**参考文章地址1：[http://www.cnblogs.com/waytofall/archive/2012/04/10/2439820.html][http_www.cnblogs.com_waytofall_archive_2012_04_10_2439820.html]**

**参考文章地址2：[http://www.cnblogs.com/xkfz007/archive/2012/05/17/2506299.html][http_www.cnblogs.com_xkfz007_archive_2012_05_17_2506299.html]**

[http_www.cnblogs.com_waytofall_archive_2012_04_10_2439820.html]: http://www.cnblogs.com/waytofall/archive/2012/04/10/2439820.html
[http_www.cnblogs.com_xkfz007_archive_2012_05_17_2506299.html]: http://www.cnblogs.com/xkfz007/archive/2012/05/17/2506299.html