【算法之数组(一)】求子数组最大和的解决方法详解

题目:

输入一个整形数组,数组里有正数也有负数。

数组中连续的一个或多个整数组成一个子数组,每个子数组都有一个和。

求所有子数组的和的最大值。

例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5,和最大的子数组为3, 10, -4, 7, 2,

因此输出为该子数组的和18。


第一种方法:

很容易想到的,就是使用双重循环:

第一层是寻找子数组中的开始位置:i

第二层是寻找子数组中的结束位置:j

代码如下:

[java] view plaincopy
  1. public static void findMaxSubArySum2(){  
  2.         //sum为子数组的和  
  3.         int sum = 0;  
  4.         //max为子数组的最大和  
  5.         int max = 0;  
  6.         //最大子数组的起始位置  
  7.         int startPos = 0;  
  8.         //最大子数组的结束位置  
  9.         int endPos = 0;  
  10.         int[] array = {-1,2,-3,12,-5,-1,9,-2};  
  11.           
  12.         for(int i=0;i<array.length;i++){  
  13.             sum = 0;//清零  
  14.             for(int j=i;j<array.length;j++){  
  15.                 sum += array[j];  
  16.                 //如果是当前的所求的和比之前的最大值还大的话,就记录下开始位置和结束位置,并且将最大值赋值给max  
  17.                 if(sum > max){  
  18.                     max = sum;  
  19.                     startPos = i;//记录当前的开始位置  
  20.                     endPos = j+1;//记录当前的结束位置  
  21.                 }  
  22.             }  
  23.         }  
  24.   
  25.         System.out.println("Max:"+max);  
  26.         System.out.println("startPos:"+startPos+",endPos:"+(endPos-1));  
  27.   
  28.     }  

时间复杂度为N*N,那么有没有什么优化的方案呢?答案是肯定的。


第二种方法:

很容易理解,当我们加上一个正数时,和会增加;当我们加上一个负数时,和会减少。如果当前得到的和是个负数,那么这个和在

接下来的累加中应该抛弃并重新清零,不然的话这个负数将会减少接下来的和。

基于这样的思路,我们可以写出如下代码:

[java] view plaincopy
  1. public static void findMaxSubArySum1(){  
  2.         //sum为子数组的和  
  3.         int sum = 0;  
  4.         //max为子数组的最大和  
  5.         int max = 0;  
  6.         //最大子数组的起始位置  
  7.         int startPos = 0;  
  8.         //最大子数组的结束位置  
  9.         int endPos = 0;  
  10.         int[] array = {-1,2,-3,12,-5,-1,9,-2};  
  11.           
  12.         for(int i=0;i<array.length;i++){  
  13.             sum += array[i];//求和  
  14.             if(sum<0){//如果当前求得总和为负数的话,就将其清零,并且开始位置从下一个位置开始  
  15.                 sum = 0;  
  16.                 startPos = i+1;  
  17.             }  
  18.             if(sum>max){//如果求得总和大于之前的最大值的话,就将sum赋值给max,同时记录最后的位置  
  19.                 max = sum;  
  20.                 endPos = i+1;  
  21.             }  
  22.         }  
  23.   
  24.         System.out.println("Max:"+max);  
  25.         System.out.println("startPos:"+startPos+",endPos:"+(endPos-1));  
  26.   
  27.     }  

这样我们可以看到优化了很多,时间复杂度为N。


题目:输入一个整形数组,数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组,每个子数组都有一个和。求所有子数组的和的最大值。要求时间复杂度为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;
}


没有更多推荐了,返回首页