求子数组最大和各种方法各种。。_求子数组和不同的数据-优快云博客

本文探讨了如何在给定的整数数组中，找出连续子数组的最大和，提出了时间复杂度为O(n)的算法解决方案。通过实例演示和代码实现，详细解释了算法的运行逻辑和关键步骤。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

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

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

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

[cpp]view plaincopy 
   
 /* 
 // Find the greatest sum of all sub-arrays 
 // Return value: if the input is valid, return true, otherwise return false 
  
 int *pData,              // an array 
 unsigned int nLength,    // the length of array 
 int &nGreatestSum        // the greatest sum of all sub-arrays 
 */  
 int start,end;  
 bool FindGreatestSumOfSubArray(int *pData, unsigned int nLength, int &nGreatestSum)  
 {  
     // if the input is invalid, return false  
     if((pData == NULL) || (nLength == 0))  
         return false;  
   
     int k=0;  
     int nCurSum = nGreatestSum = 0;  
     for(unsigned int i = 0; i < nLength; ++i)  
     {  
         nCurSum += pData[i];  
         // if the current sum is negative, discard it  
         if(nCurSum < 0)  
         {  
             nCurSum = 0;  
             k = i+1;  
         }  
         // if a greater sum is found, update the greatest sum  
         if(nCurSum > nGreatestSum)  
         {  
             nGreatestSum = nCurSum;  
             start = k;  
             end = i;  
         }  
   
     }  
   
     // if all data are negative, find the greatest element in the array  
     if(nGreatestSum == 0)  
     {  
         nGreatestSum = pData[0];  
         for(unsigned int i = 1; i < nLength; ++i)  
         {  
             if(pData[i] > nGreatestSum)  
             {  
                 nGreatestSum = pData[i];  
                 start = end = i;  
             }  
         }  
     }  
     return true;  
 }  

讨论：上述代码中有两点值得和大家讨论一下：

函数的返回值不是子数组和的最大值，而是一个判断输入是否有效的标志。如果函数返回值的是子数组和的最大值，那么当输入一个空指针是应该返回什么呢？返回0？那这个函数的用户怎么区分输入无效和子数组和的最大值刚好是0这两中情况呢？基于这个考虑，本人认为把子数组和的最大值以引用的方式放到参数列表中，同时让函数返回一个函数是否正常执行的标志。
输入有一类特殊情况需要特殊处理。当输入数组中所有整数都是负数时，子数组和的最大值就是数组中的最大元素。

方法二：编程之美2.14

[cpp]view plaincopy 
   
 /**   
 求最大子数组和（编程之美2.14，返回下标及首尾不相连）  
 ** author :liuzhiwei    
 ** date   :2011-08-17 
 起始点与结束点下标如何来记录： 
 由于我要求起始点下标、结束点下标都靠前的子数组，所以我们在动态规划的时候最好从后向前递推，这样dp[i]表示的值就是以下标i为开始的最大子数组的值，那么当dp[i]与dp[j]相同时我们选取i,j中较小的下标作为起点 
 **/  
 int maxSum(int *arr, int n, int & start, int & end)    
 {  
     int i , temp , dp , max ;  
     dp = max = arr[n-1];  
     start = end = n-1;  
     temp = n-1;  
     for(i = n - 2 ; i >= 0 ; --i)  
     {  
         if(dp > 0)  
             dp += arr[i];  
         else  
         {  
             dp = arr[i];    //抛弃当前子序列  
             temp = i;        //开始新的子序列搜索  
         }  
         if(dp > max)        //更新最大子序列  
         {  
             max = dp;  
             end = temp;  
             start = i;           //最大和增加，此时的i一定是最右端  
         }  
     }  
     return max;  
 }  
 //特殊测试用例 -10 -1 -4  

另外一种从前往后遍历的方法如下：

[cpp]view plaincopy 
   
 // 需要保存起始点与结束点下标的时候，从前往后遍历也是可以的  
 int MaxSum(int *a , int n)  
 {  
     int tempstart = 0 , sum=0 , max = -1000;  
     int i , start , end;  
     start = end = 0;  
     for(i = 0 ; i < n ; ++i)  
     {  
         if(sum < 0)  
         {  
             sum = a[i];  
             tempstart = i;  
         }  
         else  
             sum += a[i];  
         if(sum > max)  
         {  
             max = sum;  
             start = tempstart;  
             end = i;  
         }  
     }  
     return max;  
 }  

拓展问题1：
如果认为数组是环形的，即首尾相接(下标n-1的元素后面的元素下标为0)，求最大子段和。
解析：
我觉得这个问题要比第一个问题容易，有很多种方法解决。我介绍三种方法，但是其中一种我觉得有问题，但却作为《编程之美》这本书的一道练习答案，也可能是我理解错作者的算法了，一会慢慢讨论。
方法一：
这个问题的最优解一定是以下两种可能。可能一：最优解没有跨过a[n-1]到a[0]，即原问题，非环形数组。可能二：最优解跨过a[n-1]到a[0]，新问题。
对于第一种情况，我们可以按照简单的动态规划解法求得，设为max1；对于第二种情况，可以将原问题转化为数组的最小子段和问题，再用数组全部元素的和减去最小子段和，那么结果一定是跨过a[n-1]到a[0]情况中最大的子段和，设为max2。最终结果即为max1与max2中较大的那个。
例1：有数组6、-1、-6、8、2
求得max1=10，max2=16，则取较大的max2作为结果。
例2：有数组-6、8、2、6、-1
求得max1=16，max2=15，则取较大的max1作为结果。
可能有些同学会对为什么：数组元素“sum - 最小子段和 = 跨过a[n-1]到a[0]情况中的最大子段和”这一点有些疑问。我们可以这样理解：n个数的和是一定的，那么如果我们在这n个数中找到连续的一段数，并且这段数是所有连续的数的和最小的，那么“sum-最小子段和”的结果一定最大。故求得：跨过a[n-1]到a[0]情况中的最大子段和。
完整代码如下：

[cpp]view plaincopy 
   
 //环形数组求最大子数组的和  
 int MaxSum(int *a , int n)  
 {  
     int i , sum , max1 , max2 , dp, min;  
     dp = max1 = a[0];  
     for(i = 1 ; i < n ; ++i)   //最优解没有跨过a[n-1]到a[0]，即原问题，非环形数组  
     {  
         if(dp < 0)  
             dp = a[i];  
         else  
             dp += a[i];  
         if(dp > max1)  
             max1 = dp;  
     }  
     sum = min = dp = a[0];  
     for(i = 1 ; i < n ; ++i)   //可以将原问题转化为数组的最小子段和问题，再用数组全部元素的和减去最小子段和，那么结果一定是跨过a[n-1]到a[0]情况中最大的子段和  
     {  
         if(dp > 0)  
             dp = a[i];  
         else  
             dp += a[i];  
         if(dp < min)  
             min = dp;  
         sum += a[i];  
     }  
     max2 = sum - min;    //数组全部元素的和减去最小子段和  
     return max1 > max2 ? max1 : max2;;     //返回一个较大值  
 }  

第一部分即求第一种情况的最大值max1（用变量Max代替），第二部分中最初tmp为最小子段和，然后tmp值为sum-tmp；最后Max取两者较大的数。
方法二：
方法二将问题转化成另外一个问题：既然一段数的首尾可以相接，那么我们可以将数组复制，并接到自己的后面，然后我们求新数组的最大子数组的和，但这里要限制一个条件，就是最大子数组的长度不可以超过n。这样我们就把问题转化为拓展问题3了，我会在第三部分中介绍。
方法三：
方法三是《编程之美》这本书中介绍的，详细见188页，但是我觉得这种算法是错误的，可能是我理解作者的思路有问题，我将解法抄在下面，并举出一个反例，有兴趣讨论的同学希望能给我留言。
摘自《编程之美》P188：
如果数组(A[0],A[1],A[2],......,A[n-1])首尾相邻，也就是我们允许找到一段数字(A[i],A[i+1],......A[n-1],A[0],A[1],....,A[j])，使其和最大，怎么办？
(1)解没有跨过A[n-1] 到A[0] (原问题)。
(2)解跨过A[n-1]到A[0]。
对于第2种情况，只要找到从A[0]开始和最大的一段（A[0],…,A[j]）（0<=j<n），以及以A[n-1]结尾的和最大的一段（A[i],…,A[n-1]）（0<=i<n），那么，第2种情况中，和的最大值M_2为：
M_2=A[i]+…+A[n-1]+A[0]+…+A[j]
如果i <= j，则
M_2=A[0]+…+A[n-1]
否则
M_2=A[0]+…+A[j]+A[i]+…+A[n-1]
最后，再取两种情况的最大值就可以了，求解跨过A[n-1]到A[0]的情况只需要遍历数组一次，故总时间复杂度为O(N)+O(N)=O(N)。
解析：
分为两种情况讨论是没有问题的，但是对于第2种情况的解法我认为是错误的，反例：
求5个元素的数组6,-1,-6,8,2的最大子数组和：M_1为10，但是如果利用上面的方法，M_2求得的结果为9，因为从A[0]开始和最大的一段即为A[0],…,A[n-1]为9，以A[n-1]结尾的和最大的一段（A[i],…,A[n-1]）为A[n-1]，由于这两段有相交，故M_2= A[0]+…+A[n-1]。
最终结果为9，取两种情况较大的，那么结果为10。但是正确结果明显为16。
出现这种结果的原因：从A[0]开始和最大的一段虽然求的没有错，但是我们希望求得的结果并非是这一段，我们希望求得A[0]这一段，这样就不会出现两段相交的情况。
在第二部分中，我分析了两个拓展问题，后面两个拓展问题我会在第三部分中分析。
如果我上面有写的不对的地方或者你有更好的方法，希望能提出来，互相学习嘛。
拓展问题2：
有一个整数数列，其中有负数、正数，其中连续的几个数求和，求和的绝对值最大的数字串。
分析
思路

最大子矩阵和

[cpp]view plaincopy 
   
 #include <iostream>  
 #include <cstdio>  
 using namespace std;  
 #include <memory.h>  
   
 int a[102][102];  
   
 int maxSubArray(int *arr, int len)       //最大子序列和  
 {  
     int i,sum=arr[0],b=0;  
     for(i=0;i<len;++i)  
     {  
         if(b>0)  
             b+=arr[i];  
         else  
             b=arr[i];  
         if(b>sum)  
             sum=b;  
     }  
     return sum;  
 }  
 int maxSubMatrix(int n, int m,int array[102][102])  
 {  
     int i,j,h,max,sum=-100000;  
     int b[102];  
     for(i=0;i<n;i++)  
     {  
         memset(b,0,sizeof(b));       //初始化b[]  
         for(j=i;j<n;j++)             //把第i行到第j行相加,对每一次相加求出最大值  
         {  
             for(h=0;h<m;h++)  
             {  
                 b[h]+=array[j][h];    //二维数组压缩成一维数组，然后求最大子序列和  
             }  
             max=maxSubArray(b,h);   
   
             if(max>sum)  
                 sum=max;  
         }  
     }  
     return sum;  
 }  
 int main(void)  
 {  
     int n,i,j;  
     while(scanf("%d",&n)!=EOF)  
     {  
           
         for(i=0;i<n;i++)  
         {  
             for(j=0;j<n;j++)  
                 scanf("%d",&a[i][j]);  
         }  
         printf("%d\n",maxSubMatrix(n,n,a));  
     }  
     return 0;  
 }  

  
 
 

  --------------------------------------------------------------------------------------------------
 
 一个有n个整数元素（可以是负数）的一维数组，连续的子数组有很多，那连续的子数组之和的最大值是什么呢？而这个和最大的子数组是哪一段数据呢？下面就让我们来一一的剖析这个问题。首先撇开后面一个问题，不考虑究竟是哪一段数据，只需要求出最大的和就可以了。
 1、在说思路之前，先看看网上比较流行的解法，到底这里面有什么问题呢？如果数组里面有正数，OK,那一点问题都没有，比如说{-2,5,3，-6,4,-8,6}，其最大值依然是8，但是如果全是负数呢？比如说{-5,-2,-1,-4,-6}，正确答案应该是-1，但这里却只能得到0,。很明显算法有问题，或者说这种算法的适用度不是很广。
[cpp]view plaincopy 
     
 int ErrorGetMaxSubSum(int *Array, int nLen)  
 {  
     if(nLen < 1 || NULL == Array)  
         return Inf;  
   
     int b = 0;  
     int sum = 0;  
     int i;  
     for(i = 0; i < nLen; ++i)  
     {  
         //如果b<0,说明前面的数会对后面的和起负作用，故重新开始计数  
         if(b < 0)  
         {  
             b = Array[i];  
         }  
         else  
         {  
             //正常情况下就叠加  
             b += Array[i];  
         }  
         if(sum < b)  
         {  
             //如果b加的是正数，这一条一定为真。这样可以排除最后加入几个负数。  
             sum = b;  
         }  
     }  
     return sum;  
 }  
2、下面我们来考虑一下几种情况。数组的第一个元素arr[0],以及最大的一段数组arr[i].....arr[j]跟arr[0]之间的关系，有以下几种情况：
*当0=i=j时，元素arr[0]本身构成最大的一段；
*当0=i<j时，和最大的一段从arr[0]开始；
*当0<i时，元素arr[0]和最大的一段没有关系。
OK，那我们用一个sum来动态的记录某一段数据的和，用ans来记录曾经出现过的最大和。那么代码如下：
[cpp]view plaincopy 
     
 #include<stdio.h>  
 const int Inf = -1e5;  
 inline int max(const int a, const int b)  
 {  
     return a > b ? a : b;  
 }  
 //得到数组中的连续最大和  
 int GetMaxSubSum(int *arr, int nLen)  
 {  
     if(!arr || nLen < 1)  
         return Inf;  
     int ans = arr[0];  
     int sum = arr[0];  
     for(int i = 1; i < nLen; ++i)  
     {  
         if(sum < 0)  
             sum = 0;  
         sum += arr[i];  
         if(ans < sum)  
             ans = sum;  
     }  
     return ans;  
 }  
 //上面那个函数的更加精炼的版本  
 int GetMaxSubSumEx(int *arr, int nLen)  
 {  
     if(!arr || nLen < 1)  
         return Inf;  
     int ans = arr[0];  
     int sum = arr[0];  
     for(int i = 1; i < nLen; ++i)  
     {  
         sum = max(arr[i], sum + arr[i]);  
         ans = max(ans, sum);  
     }  
     return ans;  
 }  
3、如果说在给出最大和的同时，需要知道是哪一段数据构成了这个最大和。那么每一次sum被重置为0的时候，就可能是新的数据段的开始，用temp记下。每一次用sum来更新ans的时候，就说明当前这一段数据是最优的，当前这一段数据是[temp,i]，所以更新[b,e]。
[cpp]view plaincopy 
     
 //在得到数组最大和的同时，得到是哪一段数据  
 int GetMaxSubSum(int *arr, int nLen, int &b, int &e)  
 {  
     if(!arr || nLen < 1)  
         return Inf;  
     int ans = arr[0];  
     int sum = arr[0];  
     int temp = 0;  
     b = e = 0;  
     for(int i = 1; i < nLen; ++i)  
     {  
         if(sum < 0)  
         {  
             sum = 0;  
             temp = i;  
         }  
         sum += arr[i];  
         if(ans < sum)  
         {  
             ans = sum;  
             b = temp;  
             e = i;  
         }  
     }  
     return ans;  
 }  
 //打印数组  
 void Print(int *arr, int nLen)  
 {  
     if(!arr|| nLen < 1)  
     {  
         return;  
     }  
     int i;  
     for(i = 0; i < nLen; ++i)  
     {  
         printf("%d ", arr[i]);  
     }  
     printf("\n");  
 }  
4、照例，最后给出main函数的调用方法。仅供参考，不需要者可以pass掉。
[cpp]view plaincopy 
     
 int main()  
 {  
     const int N = 20;  
     int arr[N];  
     int i,n,ans;  
     int b,e;  
     while(scanf("%d", &n) != EOF)  
     {  
         for(i = 0; i < n; ++i)  
             scanf("%d", &arr[i]);  
         ans = GetMaxSubSum(arr, n);//方法1的调用  
         printf("最大和为：%d\n", ans);  
         ans = GetMaxSubSumEx(arr, n);//方法1等价形式的调用  
         printf("最大和为：%d\n", ans);  
         ans = ErrorGetMaxSubSum(arr, n);//错误方法的调用  
         printf("最大和为：%d\n", ans);  
         ans = GetMaxSubSum(arr, n, b, e);//方法1扩展的调用  
         printf("最大和为：%d\n数据段为：", ans);  
         Print(&arr[b], e - b + 1);  
     }  
 }  
最后给出几组测试用例的结果，当然其中有一个是调用错误的方法得到的错误结果，一眼就可以看到啦！