求子数组最大和的解决方法详解
作者：
本篇文章是对求子数组最大和的解决方法进行了详细的分析介绍，需要的朋友参考下
题目：输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。求所有子数组的和的最大值。要求时间复杂度为O(n)。
例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2，因此输出为该子数组的和18。
如果不考虑时间复杂度，我们可以枚举出所有子数组并求出他们的和。不过非常遗憾的是，由于长度为n的数组有O(n2)个子数组；而且求一个长度为n的数组的和的时间复杂度为O(n)。因此这种思路的时间是O(n3)。
很容易理解，当我们加上一个正数时，和会增加；当我们加上一个负数时，和会减少。如果当前得到的和是个负数，那么这个和在接下来的累加中应该抛弃并重新清零，不然的话这个负数将会减少接下来的和。基于这样的思路，我们可以写出如下代码：
/*
// 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
/**
求最大子数组和（编程之美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
另外一种从前往后遍历的方法如下：
// 需要保存起始点与结束点下标的时候，从前往后遍历也是可以的
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]情况中的最大子段和。
完整代码如下：
//环形数组求最大子数组的和
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：
有一个整数数列，其中有负数、正数， 其中连续的几个数求和，求和的绝对值最大的数字串。
分析
思路
最大子矩阵和
#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;
}
例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2，因此输出为该子数组的和18。
如果不考虑时间复杂度，我们可以枚举出所有子数组并求出他们的和。不过非常遗憾的是，由于长度为n的数组有O(n2)个子数组；而且求一个长度为n的数组的和的时间复杂度为O(n)。因此这种思路的时间是O(n3)。
很容易理解，当我们加上一个正数时，和会增加；当我们加上一个负数时，和会减少。如果当前得到的和是个负数，那么这个和在接下来的累加中应该抛弃并重新清零，不然的话这个负数将会减少接下来的和。基于这样的思路，我们可以写出如下代码：
复制代码 代码如下:
/*
// 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
复制代码 代码如下:
/**
求最大子数组和（编程之美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
另外一种从前往后遍历的方法如下：
复制代码 代码如下:
// 需要保存起始点与结束点下标的时候，从前往后遍历也是可以的
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]情况中的最大子段和。
完整代码如下：
复制代码 代码如下:
//环形数组求最大子数组的和
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：
有一个整数数列，其中有负数、正数， 其中连续的几个数求和，求和的绝对值最大的数字串。
分析
思路
最大子矩阵和
复制代码 代码如下:
#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;
}