求最大连续子数组的和

看到过一道面试题，网上搜了一下资料，整理一下记下来。题目是这么说的：

输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。求所有子数组的和的最大值。要求时间复杂度为O(n)。

        例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2，因此输出为该子数组的和18。

如果不考虑时间复杂度，我们可以枚举出所有子数组并求出他们的和。不过非常遗憾的是，由于长度为n的数组有O(n²)，具体是n*(n+1)/2个子数组；而且求一个长度为n的数组的和的时间复杂度为O(n)。因此这种思路的时间是O(n³)。

 

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

 

解法一:穷举遍历，我们先用最简单的方法，把所有的连续子数组列出来，然后计算最大连续子数组的和，设置两个变量i和j为子数组的边界，这两个变量都要遍历整个数组，然后还需要一个下标来遍历整个子数组求和，总的复杂度是O(n^3)，代码如下：

int MaxSubSum(int *arr,int n)
 2 {
 3     int max = -INFINITE;
 4     int sum = 0;
 5     for (int i = 0 ; i < n ; i++)
 6     {
 7         for (int j = i ; j < n ; j++)
 8         {
 9             for (int k = i ; k <= j ; k++)
10             {
11                 sum += arr[k];
12             }
13             if (sum > max)
14             {
15                 max = sum;
16             }
17         }
18     }
19     return max;
20 }

　　对解法一改进一下，我们发现不需要再使用k去遍历子数组，因为每次j移动都会产生新的子数组，所以每次j移动时进行一下比较，就不会漏掉最大值所以去掉k，只要i和j移动就可以，去掉一层循环，时间复杂度降为O(n^2),代码如下：

int MaxSubSum(int *arr,int n)
 2 {
 3     int max = -INFINITE;
 4     int sum = 0;
 5     for (int i = 0 ; i < n ; i++)
 6     {
 7         sum = 0;
 8         for (int j = i ; j < n ; j++)
 9         {
10             sum += arr[j];
11             if (sum > max)
12                 max = sum;
13         }
14     }
15     return max;
16 }
17

　　解法二：分治算法，跟二分查找的思想相似，我们可以分情况讨论这个问题是不是符合二分查找的条件

情况1：这个满足最大和的连续子数组全部在数组的左半部或者右半部，例如：左半部arr[i]……arr[n/2-1]，或者右半部arr[n/2]……arr[j]，这种情况下可以直接使用递归调用。

情况2：满足最大和的连续子数组跨过了本书组的中间点，例如连续子数组arr[i]……arr[n/2-1]arr[n/2]……arr[j]，这种情况下只要在左半部寻找以arr[n/2-1]为结尾，在右半部寻找以arr[n/2]开头的两个满足最大和的连续子数组，求和，由于这个已知起点，只需要一个游标即可，所以复杂度是2*O(n/2)=O(n)。

综合以上的两种情况，满足分治算法的递归式：T(n)=2T(n/2)+O(n)=O(n*logn)。代码如下：

 1 int MaxSubSum(int *arr,int Left,int Right)
 2 {
 4     int MaxLeftSum,MaxRightSum;  //最大连续子数组没被中间的center切开时左右部分最大连续子数组之和
 6     int MaxLeftPartSum,MaxRightPartSum;//最大连续子数组被center切开时，最大子数组左右两部分的和
 8     int LeftPartSum,RightPartSum;  //临时变量，用于存储计算出来的和
 9     int Center,i; 
10 
11    
12     if(Left == Right)   //整个数组只有一个元素
13     {
14         if(arr[Left] > 0)   
15             return arr[Left];   
16         else   
17             return 0;
18     }
19 
20     //递归调用。分别计算左右子数组的最大和子数组。
21     //即假设最大和子数组没有被Center切割
22     Center = (Left+Right)/2;   
23     MaxLeftSum = MaxSubSum(arr,Left,Center);   
24     MaxRightSum = MaxSubSum(arr,Center+1,Right);   
25 
26     //假设最大和子数组被Center切开的情况
27     //那么需要从Center开始向两侧计算
28     MaxLeftPartSum = 0;   
29     LeftPartSum = 0;   
30     for(i = Center ; i >= Left; --i )   //从center向左边计算
31     {   
32         LeftPartSum += arr[i];   
33         if(LeftPartSum > MaxLeftPartSum)   
34             MaxLeftPartSum = LeftPartSum;   
35     }   
36     MaxRightPartSum = 0;   
37     RightPartSum = 0;   
38     for(i = Center+1 ; i <= Right ; ++i)  //从center向右计算
39     {   
40         RightPartSum += arr[i];   
41         if(RightPartSum > MaxRightPartSum)   
42             MaxRightPartSum = RightPartSum;   
43     }
44     //返回三者中的最大值。
45     return max(max(MaxLeftSum,MaxRightSum),MaxLeftPartSum+MaxRightPartSum);   
46 }

　解法三：动态规划思想，对于这个问题我们可以“从后往前”分析，我们考虑一下最后一个元素arr[n-1]与最大连续子数组的关系，有如下三种关系

             1.arr[n-1]单独构成最大子数组

　　　　  2.最大连续子数组以arr[n-1]结尾

　　　　  3.最大连续子数组跟arr[n-1]没关系，最大连续子数组在arr[0—n-2]范围内，转为考虑元素arr[n-2]

从上面我们可以看出，问题分解成三个子问题，最大子数组就是这三个子问题的最大值，现在假设：

　　　　  1.以arr[n-1]为结尾的最大子数组和为End[n-1]

　　　　  2.在[0-n-1]范围内的最大子数组和为All[n-1]

如果最大连续子数组跟最后一个元素无关，即最大和为All[n-2](存在范围为[0-n-2])，则解All[n-1]为三种情况的最大值，即All[n-1] = max{ arr[n-1]，End[n-1]，All[n-2] }。从后向前考虑，初始化的情况分别为arr[0]，以arr[0]结尾，即End[0] = arr[0]，最大和范围在[0,0]之内，即All[0]=arr[0]。根据上面分析，给出状态方程：All[i] = max{ arr[i]，End[i-1]+arr[i]，All[i-1] }，代码如下：

/* DP base version*/
#define max(a,b) ( a > b ? a : b)
 
int MaxSubSum(int * arr, int size)
{
    int End[30] = {-INF};
    int All[30] = {-INF};
    End[0] = All[0] = arr[0];
 
    for(int i = 1; i < size; ++i)
    {
        End[i] = max(End[i-1]+arr[i],arr[i]);
        All[i] = max(End[i],All[i-1]);
    }
    return All[size-1];
}

　　我们还可以由动态规划得到另一种O(n)的实现方式，仔细看上面动态规划方案的代码，End[i] = max{arr[i]，End[i-1]+arr[i]}，如果End[i-1]<0，那么End[i]=arr[i]，什么意思？End[i]表示以i元素为结尾的子数组和，如果某一位置使得它小于0了，那么就自当前的arr[i]从新开始，且End[i]最初是从arr[0]开始累加的，所以这可以启示我们：我们只需从头遍历数组元素，并累加求和，如果和小于0了就自当前元素从新开始，否则就一直累加，取其中的最大值便求得解。

其实上面的方法虽说是从动态规划推导出来的，但是写完发现也是很直观的方法，最终的最终，这个问题转化为这样，求最大和，那就一直累加呗，只要大于0，就说明当前的“和”可以继续增大，如果小于0了，说明“之前的最大和”已经不可能继续增大了，就从新开始，如此这样。实现代码如下

#include<iostream>
using namespace std;
int maxsum(int *arr,int size)
{
	int max=-1000;
	int sum=0;
	for(int i=0;i<size;i++)
	{
		if(sum<0)
			sum=arr[i];
		else
			sum+=arr[i];
		if(sum>max)
			max=sum;
	}
	return max;
}

int main()
{
	int arr[8]={1,-2,3,10,-4,7,2,-5};
	int m=maxsum(arr,8);
	cout<<m<<endl;
	return 0;
}

　　如果对问题进一步扩展一下，要求返回最大连续子数组的始末位置，到了这里也是比较容易实现的，我们知道，每当当前子数组和的小于0时，便是新一轮子数组的开始，每当更新最大和时，便对应可能的结束下标，这个时候，只要顺便用本轮的起始和结束位置更新始末位置就可以，程序结束，最大子数组和以及其始末位置便一起被记录下来了，代码如下：

/* 最大子数组 返回起始位置 */
void Maxsum_location(int * arr, int size, int & start, int & end)
{
    int maxSum = -INF;
    int sum = 0;
    int curstart = start = 0;  /* curstart记录每次当前起始位置 */
    for(int i = 0; i < size; ++i)
    {
        if(sum < 0)
        {
            sum = arr[i];
            curstart = i;     /* 记录当前的起始位置 */
        }else
        {
            sum += arr[i];
        }
        if(sum > maxSum)
        {
            maxSum = sum;
            start = curstart; /* 记录并更新最大子数组起始位置 */
            end = i;
        }
    }
}

　　

 

本文的第三种思路参考自http://www.ahathinking.com/archives/120.html，题目还有很多其他解法和扩展练习，有兴趣的可以查看以上的参考链接。