求数组的子数组之和的最大值

转自：http://blog.csdn.net/v_JULY_v/article/details/6444021

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

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

 

分析：
1、求一个数组的最大子数组和，如此序列1, -2, 3, 10, -4, 7, 2, -5，我想最最直观也是最野蛮的办法便是，三个for循环三层遍历，求出数组中每一个子数组的和，最终求出这些子数组的最大的一个值。
记Sum[i, …, j]为数组A中第i个元素到第j个元素的和（其中0 <= i <= j < n），遍历所有可能的Sum[i, …, j]，那么时间复杂度为O（N^3）：

[cpp] view plain copy

1. //本段代码引自编程之美  
2. int MaxSum(int* A, int n)  
3. {  
4. int maximum = -INF;   
5. int sum=0;   
6. for(int i = 0; i < n; i++)  
7. {  
8.    for(int j = i; j < n; j++)  
9.    {  
10.       for(int k = i; k <= j; k++)  
11.       {  
12.         sum += A[k];  
13.       }  
14.       if(sum > maximum)  
15.       maximum = sum;  
16.       sum=0;  
17.    }  
18. }  
19. return maximum;  
20. }   
21.   
22.    

 

2、现在给出O（N）时间复杂度的算法：

[cpp] view plain copy

1. #include <iostream.h>     
2.     
3. int maxSum(int* a, int n)    
4. {    
5.     int sum=0;    
6.     //其实要处理全是负数的情况，很简单，如稍后下面第3点所见，直接把这句改成："int sum=a[0]"即可     
7.     //也可以不改，当全是负数的情况，直接返回0，也不见得不行。     
8.     int b=0;    
9.         
10.     for(int i=0; i<n; i++)    
11.     {    
12.         if(b<0)           //...     
13.             b=a[i];    
14.         else    
15.             b+=a[i];    
16.         if(sum<b)    
17.             sum=b;    
18.     }    
19.     return sum;    
20. }    
21.     
22. int main()    
23. {    
24.     int a[10]={1, -2, 3, 10, -4, 7, 2, -5};    
25.     //int a[]={-1,-2,-3,-4};  //测试全是负数的用例     
26.     cout<<maxSum(a,8)<<endl;    
27.     return 0;    
28. }    
29.     
30. /*-------------------------------------   
31. 解释下：   
32. 例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5，   
33. 那么最大的子数组为3, 10, -4, 7, 2，   
34. 因此输出为该子数组的和18。   
35.    
36. 所有的东西都在以下俩行，   
37. 即：   
38. b  ：  0  1  -1  3  13   9  16  18  13     
39. sum：  0  1   1  3  13  13  16  18  18   
40.      
41. 其实算法很简单，当前面的几个数，加起来后，b<0后，   
42. 把b重新赋值，置为下一个元素，b=a[i]。   
43. 当b>sum，则更新sum=b;   
44. 若b<sum，则sum保持原值，不更新。。  

3、不少朋友看到上面的答案之后，认为上述思路2的代码，没有处理全是负数的情况，当全是负数的情况时，我们可以让程序返回0，也可以让其返回最大的那个负数，修改后的处理全是负数情况（返回最大的负数）的代码：

[cpp] view plain copy

1. #include <iostream.h>     
2. #define n 4           //多定义了一个变量     
3.     
4. int maxsum(int a[n])      
5. //于此处，你能看到上述思路2代码（指针）的优势     
6. {    
7.     int max=a[0];       //全负情况，返回最大数     
8.     int sum=0;    
9.     for(int j=0;j<n;j++)    
10.     {    
11.         if(sum>=0)     //如果加上某个元素，sum>=0的话，就加     
12.             sum+=a[j];    
13.         else       
14.             sum=a[j];  //如果加上某个元素，sum<0了，就不加     
15.         if(sum>max)    
16.             max=sum;    
17.     }    
18.     return max;    
19. }    
20.     
21. int main()    
22. {    
23.     int a[]={-1,-2,-3,-4};    
24.     cout<<maxsum(a)<<endl;    
25.     return 0;    
26. }   
    

4、DP解法的具体方程设sum[i] 为前i个元素中，包含第i个元素且和最大的连续子数组，result 为已找到的子数组中和最大的。对第i+1个元素有两种选择：做为新子数组的第一个元素、放入前面找到的子数组。
sum[i+1] = max(a[i+1], sum[i] + a[i+1])
result = max(result, sum[i])

 

扩展：
1、如果数组是二维数组，同样要你求最大子数组的和列?（详见编程之美2.15）
2、如果是要你求子数组的最大乘积列?
3、如果同时要求输出子段的开始和结束列?

 

附：

1. 下面给出《Data structures and Algorithm analysis in C》中4种实现。

   [cpp]
   1. //Algorithm 1:时间效率为O(n*n*n)     
   2. int MaxSubsequenceSum1(const int A[],int N)    
   3. {    
   4.     int ThisSum=0 ,MaxSum=0,i,j,k;    
   5.     for(i=0;i<N;i++)    
   6.         for(j=i;j<N;j++)    
   7.         {    
   8.             ThisSum=0;    
   9.             for(k=i;k<j;k++)    
   10.                 ThisSum+=A[k];    
   11.                 
   12.             if(ThisSum>MaxSum)    
   13.                 MaxSum=ThisSum;    
   14.         }    
   15.         return MaxSum;    
   16. }    
   17.     
   18. //Algorithm 2:时间效率为O(n*n)     
   19. int MaxSubsequenceSum2(const int A[],int N)    
   20. {    
   21.     int ThisSum=0,MaxSum=0,i,j,k;    
   22.     for(i=0;i<N;i++)    
   23.     {    
   24.         ThisSum=0;    
   25.         for(j=i;j<N;j++)    
   26.         {    
   27.             ThisSum+=A[j];    
   28.             if(ThisSum>MaxSum)    
   29.                 MaxSum=ThisSum;    
   30.         }    
   31.     }    
   32.     return MaxSum;    
   33. }    
   34.     
   35. //Algorithm 3:时间效率为O(n*log n)     
   36. //算法3的主要思想：采用二分策略，将序列分成左右两份。     
   37. //那么最长子序列有三种可能出现的情况，即     
   38. //【1】只出现在左部分.     
   39. //【2】只出现在右部分。     
   40. //【3】出现在中间，同时涉及到左右两部分。     
   41. //分情况讨论之。     
   42. static int MaxSubSum(const int A[],int Left,int Right)    
   43. {    
   44.     int MaxLeftSum,MaxRightSum;              //左、右部分最大连续子序列值。对应情况【1】、【2】     
   45.     int MaxLeftBorderSum,MaxRightBorderSum;  //从中间分别到左右两侧的最大连续子序列值，对应case【3】。     
   46.     int LeftBorderSum,RightBorderSum;    
   47.     int Center,i;    
   48.     if(Left == Right)Base Case    
   49.         if(A[Left]>0)    
   50.             return A[Left];    
   51.         else    
   52.             return 0;    
   53.         Center=(Left+Right)/2;    
   54.         MaxLeftSum=MaxSubSum(A,Left,Center);    
   55.         MaxRightSum=MaxSubSum(A,Center+1,Right);    
   56.         MaxLeftBorderSum=0;    
   57.         LeftBorderSum=0;    
   58.         for(i=Center;i>=Left;i--)    
   59.         {    
   60.             LeftBorderSum+=A[i];    
   61.             if(LeftBorderSum>MaxLeftBorderSum)    
   62.                 MaxLeftBorderSum=LeftBorderSum;    
   63.         }    
   64.         MaxRightBorderSum=0;    
   65.         RightBorderSum=0;    
   66.         for(i=Center+1;i<=Right;i++)    
   67.         {    
   68.             RightBorderSum+=A[i];    
   69.             if(RightBorderSum>MaxRightBorderSum)    
   70.                 MaxRightBorderSum=RightBorderSum;    
   71.         }    
   72.         int max1=MaxLeftSum>MaxRightSum?MaxLeftSum:MaxRightSum;    
   73.         int max2=MaxLeftBorderSum+MaxRightBorderSum;    
   74.         return max1>max2?max1:max2;    
   75. }    
   76.     
   77. //Algorithm 4:时间效率为O(n)     
   78. //同上述第一节中的思路3、和4。     
   79. int MaxSubsequenceSum(const int A[],int N)    
   80. {    
   81.     int ThisSum,MaxSum,j;    
   82.     ThisSum=MaxSum=0;    
   83.     for(j=0;j<N;j++)    
   84.     {    
   85.         ThisSum+=A[j];    
   86.         if(ThisSum>MaxSum)    
   87.             MaxSum=ThisSum;    
   88.         else if(ThisSum<0)    
   89.             ThisSum=0;    
   90.     }    
   91.     return MaxSum;    
   92. }