求子数组的最大和

http://blog.csdn.net/v_JULY_v/article/details/6444021

作者 ：v_July_v

 

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

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

分析：这个问题在各大公司面试中出现频率之频繁，被人引用次数之多，非一般面试题可与之匹敌。单凭这点，就没有理由不入选狂想曲系列中了。此题曾作为本人之前整理的微软100题中的第3题，至今反响也很大。ok，下面，咱们来一步一步分析这个题：
      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）：

//本段代码引自编程之美
int MaxSum(int* A, int n)
{
int maximum = -INF;
int sum=0;  
for(int i = 0; i < n; i++)
{
  for(int j = i; j < n; j++)
  {
   for(int k = i; k <= j; k++)
   {
    sum += A[k];
   }
   if(sum > maximum)
    maximum = sum;

   sum=0;   //这里要记得清零，否则的话sum最终存放的是所有子数组的和。也就是编程之美上所说的bug。多谢苍狼。
  }
}
return maximum;
}

      2、其实这个问题，在我之前上传的微软100题，答案V0.2版[第1-20题答案]，便直接给出了以下O（N）的算法：

 

//copyright@ July 2010/10/18  
//updated，2011.05.25.  
#include <iostream.h>  
  
int maxSum(int* a, int n)  
{  
    int sum=0;  
    //其实要处理全是负数的情况，很简单，如稍后下面第3点所见，直接把这句改成："int sum=a[0]"即可  
    //也可以不改，当全是负数的情况，直接返回0，也不见得不行。  
    int b=0;  
      
    for(int i=0; i<n; i++)  
    {  
        if(b<0)           //...  
            b=a[i];  
        else  
            b+=a[i];  
        if(sum<b)  
            sum=b;  
    }  
    return sum;  
}  
  
int main()  
{  
    int a[10]={1, -2, 3, 10, -4, 7, 2, -5};  
    //int a[]={-1,-2,-3,-4};  //测试全是负数的用例  
    cout<<maxSum(a,8)<<endl;  
    return 0;  
}  
  
/*------------------------------------- 
解释下： 
例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5， 
那么最大的子数组为3, 10, -4, 7, 2， 
因此输出为该子数组的和18。 
 
所有的东西都在以下俩行， 
即： 
b  ：  0  1  -1  3  13   9  16  18  13   
sum：  0  1   1  3  13  13  16  18  18 
   
其实算法很简单，当前面的几个数，加起来后，b<0后， 
把b重新赋值，置为下一个元素，b=a[i]。 
当b>sum，则更新sum=b; 
若b<sum，则sum保持原值，不更新。。July、10/31。 
----------------------------------*/  

 

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

//copyright@ July  
//July、updated，2011.05.25。  
#include <iostream.h>  
#define n 4           //多定义了一个变量  
  
int maxsum(int a[n])    
//于此处，你能看到上述思路2代码（指针）的优势  
{  
    int max=a[0];       //全负情况，返回最大数  
    int sum=0;  
    for(int j=0;j<n;j++)  
    {  
        if(sum>=0)     //如果加上某个元素，sum>=0的话，就加  
            sum+=a[j];  
        else     
            sum=a[j];  //如果加上某个元素，sum<0了，就不加  
        if(sum>max)  
            max=sum;  
    }  
    return max;  
}  
  
int main()  
{  
    int a[]={-1,-2,-3,-4};  
    cout<<maxsum(a)<<endl;  
    return 0;  
}  

4、DP解法的具体方程：@flyinghearts：设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、如果是要你求子数组的最大乘积列?
3、如果同时要求输出子段的开始和结束列?

第二节、Data structures and Algorithm analysis in C

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

//感谢网友firo  
//July、2010.06.05。  
  
//Algorithm 1:时间效率为O(n*n*n)  
int MaxSubsequenceSum1(const int A[],int N)  
{  
    int ThisSum=0 ,MaxSum=0,i,j,k;  
    for(i=0;i<N;i++)  
        for(j=i;j<N;j++)  
        {  
            ThisSum=0;  
            for(k=i;k<j;k++)  
                ThisSum+=A[k];  
              
            if(ThisSum>MaxSum)  
                MaxSum=ThisSum;  
        }  
        return MaxSum;  
}  
  
//Algorithm 2:时间效率为O(n*n)  
int MaxSubsequenceSum2(const int A[],int N)  
{  
    int ThisSum=0,MaxSum=0,i,j,k;  
    for(i=0;i<N;i++)  
    {  
        ThisSum=0;  
        for(j=i;j<N;j++)  
        {  
            ThisSum+=A[j];  
            if(ThisSum>MaxSum)  
                MaxSum=ThisSum;  
        }  
    }  
    return MaxSum;  
}  
  
//Algorithm 3:时间效率为O(n*log n)  
//算法3的主要思想：采用二分策略，将序列分成左右两份。  
//那么最长子序列有三种可能出现的情况，即  
//【1】只出现在左部分.  
//【2】只出现在右部分。  
//【3】出现在中间，同时涉及到左右两部分。  
//分情况讨论之。  
static int MaxSubSum(const int A[],int Left,int Right)  
{  
    int MaxLeftSum,MaxRightSum;              //左、右部分最大连续子序列值。对应情况【1】、【2】  
    int MaxLeftBorderSum,MaxRightBorderSum;  //从中间分别到左右两侧的最大连续子序列值，对应case【3】。  
    int LeftBorderSum,RightBorderSum;  
    int Center,i;  
    if(Left == Right)Base Case  
        if(A[Left]>0)  
            return A[Left];  
        else  
            return 0;  
        Center=(Left+Right)/2;  
        MaxLeftSum=MaxSubSum(A,Left,Center);  
        MaxRightSum=MaxSubSum(A,Center+1,Right);  
        MaxLeftBorderSum=0;  
        LeftBorderSum=0;  
        for(i=Center;i>=Left;i--)  
        {  
            LeftBorderSum+=A[i];  
            if(LeftBorderSum>MaxLeftBorderSum)  
                MaxLeftBorderSum=LeftBorderSum;  
        }  
        MaxRightBorderSum=0;  
        RightBorderSum=0;  
        for(i=Center+1;i<=Right;i++)  
        {  
            RightBorderSum+=A[i];  
            if(RightBorderSum>MaxRightBorderSum)  
                MaxRightBorderSum=RightBorderSum;  
        }  
        int max1=MaxLeftSum>MaxRightSum?MaxLeftSum:MaxRightSum;  
        int max2=MaxLeftBorderSum+MaxRightBorderSum;  
        return max1>max2?max1:max2;  
}  
  
//Algorithm 4:时间效率为O(n)  
//同上述第一节中的思路3、和4。  
int MaxSubsequenceSum(const int A[],int N)  
{  
    int ThisSum,MaxSum,j;  
    ThisSum=MaxSum=0;  
    for(j=0;j<N;j++)  
    {  
        ThisSum+=A[j];  
        if(ThisSum>MaxSum)  
            MaxSum=ThisSum;  
        else if(ThisSum<0)  
            ThisSum=0;  
    }  
    return MaxSum;  
}   

 

 

int max(int x,int y)
{
	return (x>y)?x:y;
}
//sum[i+1]=max(a[i+1],sum[i]+a[i+1]
//result=max(result,sum[i]);
int MaxSum(int* A,int n)
{
	//int nStart=A[n-1];
	//int nAll=A[n-1];
	int nStart=A[0];
	int nAll=A[0];
	for(int i=1;i<n;i++)
	{
		nStart=max(A[i],nStart+A[i]);
		nAll=max(nStart,nAll);
	}
	return nAll;
}
//算法1  ThisSum[i,...j]为数组A中第i个元素到第j个元素的和
int MaxSubsequenceSum1(const int A[],int N)
{
	int ThisSum=0,MaxSum=0,i,j,k;
	for(i=0;i<N;i++)
	{
		for(j=i+1;j<N;j++)  //从i 到j的元素的  0到1 0到2 0到3 0到N-1  1到2
		{
			ThisSum=0;
			for(k=i;k<=j;k++)//计算从i到j的所有元素的和赋值给ThisSum
				ThisSum+=A[k];
			if(ThisSum>MaxSum)//如果ThisSum大于MaxSum 则更新MaxSum
				MaxSum=ThisSum;
		}
	}
	return MaxSum;
}

//分治策略
/*
采用二分策略，将序列分为左右两份，
那么最长的子序列只出现在以下三个地方:
1. 只出现在左部分
2. 只出现在右部分
3. 出现在中间，同时涉及到左右两部分
*/
int MaxSubSum(const int A[],int Left,int Right)
{
	int MaxLeftSum,MaxRightSum;//左右部分最大连续子序列的值，对应情况[1] [2]
	int MaxLeftBorderSum,MaxRightBorderSum;//从中间分别到左右两侧的最大连续子序列值 对应 case [3]
	int LeftBorderSum,RightBorderSum;
	int Center,i;
	if(Left==Right)
	{
		if(A[Left]>0)
			return A[Left];
		else
			return 0;
	}
	Center=(Left+Right)>>1;//Left和Right的中间值
	MaxLeftSum=MaxSubSum(A,Left,Center);//左部分最大连续子序列的值 
	MaxRightSum=MaxSubSum(A,Center+1,Right);//右部分最大连续子序列的值
	MaxLeftBorderSum=0;//从中间到左侧最大连续子序列的值
	LeftBorderSum=0;
	for(i=Center;i>=Left;i--)
	{
		LeftBorderSum+=A[i];
		if(LeftBorderSum>MaxLeftBorderSum)
		{
			MaxLeftBorderSum=LeftBorderSum;
		}
	}
	MaxRightBorderSum=0;//从中间到右侧最大连续子序列的值
	RightBorderSum=0;//存储中间变量
	for(i=Center+1;i<=Right;i++)
	{
		RightBorderSum+=A[i];
		if(RightBorderSum>MaxRightBorderSum)
			MaxRightBorderSum=RightBorderSum;
	}
	int max1=MaxLeftSum>MaxRightSum?MaxLeftSum:MaxRightSum;
	int max2=MaxLeftBorderSum+MaxRightBorderSum;
	return max1>max2?max1:max2;
}

int main()
{
	int a[]={0,-2,3,5,-1,10};
	cout<<MaxSubSum(a,0,sizeof(a)/sizeof(int)-1);
	return 0;}

 

int max(int x,int y)
{
	return (x>y)?x:y;
}
//sum[i+1]=max(a[i+1],sum[i]+a[i+1]
//result=max(result,sum[i]);
int MaxSum(int* A,int n)
{
	//int nStart=A[n-1];
	//int nAll=A[n-1];
	int nStart=A[0];
	int nAll=A[0];
	for(int i=1;i<n;i++)
	{
		//当nStart+A[i]小于A[i]的时候 也就是说nStart小于0的时候 选择A[i],否则选择nStart+A[i]
		nStart=max(A[i],nStart+A[i]);
		//取nStart和nAll之间的最大值
		nAll=max(nStart,nAll);
	}
	return nAll;
}