算法导论——最大子数组问题

方法一：

暴力求解

#include<stdio.h>
#include<stdlib.h>
#include<limits.h>
int maxsubset(int *a,int len){
int summax=INT_MIN;
int i,j,k;
for(i=0;i<len;i++)
for(j=i;j<len;j++){
int temp=0;
for(k=i;k<=j;k++)
temp+=a[k];
if(temp > summax) summax=temp;
}
return summax;
}
int main(){
int a[]={3,-1,2,5,-3,4,-6,-7,1,8,-3,5,9};
printf("the maxsubset:%d\n",maxsubset(a,13));
return 0;
}

方法二：分治求解

#include<stdio.h>
#include<stdlib.h>
#include<limits.h>
int cross_middle(int *a,int l,int m,int r){
int i,
sum=0,
l_max=INT_MIN,
r_max=INT_MIN;
for(i=m;i>=l;i--){
sum+=a[i];
if(sum > l_max) l_max=sum;
}
sum=0;
for(i=m+1;i<=r;i++){//最早i=m,出现BUG
sum+=a[i];
if(sum>r_max) r_max=sum;
}
return (l_max+r_max);
}
int maxsubset(int *a,int l,int r){
if(l == r) return a[l];
//if(l>r) return 0;

int m=(l+r)/2,
l_max=INT_MIN,
r_max=INT_MIN,
c_max=INT_MIN;
l_max=maxsubset(a,l,m);
r_max=maxsubset(a,m+1,r);
c_max=cross_middle(a,l,m,r);
if(l_max >= r_max&&l_max >= c_max) return l_max;
else if(r_max >= l_max&&r_max >= c_max) return r_max;
else return c_max;
}
int main(){
int a[]={3,-1,2,5,-3,4,-6,-7,1,8,-3,5,9};

printf("the maxsubset:%d\n",maxsubset(a,0,12));
return 0;
}

方法三 线性时间实现：

#include<stdio.h>
#include<stdlib.h>
#include<limits.h>
int maxsubset(int *a,int l,int r){
int i,
temp=0,
summax=INT_MIN;
for(i=l;i<=r;i++){
temp+=a[i];
if(temp > summax) summax=temp;
if(temp < 0) temp=0;
}
return summax;
}
int main(){
int a[]={3,-1,2,5,-3,4,-6,-7,1,8,-3,5,9};

printf("the maxsubset:%d\n",maxsubset(a,0,12));
return 0;
}

方法三线性时间实现基于这样的思路：

如果a[1..j]已经得到了其最大子数组，那么a[1..j+1]最大子数组只能是两种情况

（1）a[1..j+1]的最大子数组就是a[1..j];

（2）a[1..j+1]的最大子数组是a[i..j+1],1<=i<=j;

那么，如何求得所谓的（2）中的a[i..j+1]呢？

首先需要承认这样的事实，如果一个数组a[p..r]求和得到负值，那么数组a[p..r+1]的最大子数组肯定不会是a[p..r+1]，因为a[p..r]+a[r+1]<a[r+1].

在以上程序中，我们用temp存储所谓的a[p..r]，只要a[p..r]的求和是负值，那么从下一个a[r+1]值开始，temp重新从零开始求和，只要temp > summax,就更新summax,这样，我们一次遍历后，就能得到最大的summax,接下来，我们证明该算法是有效的

证明：

对于所有数组元素，这样的元素对数组进行划分，如果加上该元素之前temp>0且temp+a[i]<0，那么该元素a[i]是一个边界，这样，数组会形成好多段，每段结束元素都满足temp>0且temp+a[i]<0.所以我们能得到多个划分块a[p..q]，每个划分快的和是负值，划分块有这样的性质，对任意p<=i<q,显然，sum(a[p..i])>=0且sum(a[i..q]）<0;

我们要证明

（1）最大子数组一定在划分块之内

证明：

根据划分快性质，容易证明，只要子数组横跨多个划分快，其求和值必定小于某个单独的划 分快中的数组求和。

（2）一定存在首元素以划分块的首元素开始的最大子数组。

证明：

对于某个划分快a[p..q],假设存在a[i..j],其中p<i<=j<q,那么根据划分块性质，a[p..i-1]+a[i..j]>=a[i..j]必定成立,得证。

所以，经历一次遍历，对于每个划分块，从首元素开始求和，得到最大值更新summax,一定能够得到最大子数组的值。

//-------------------------------------------------------------------------

求数组的最大子数组的积怎么求呢？

解决方法是保存最大负值和最大正值，实现如下：

#include<stdio.h>
#include<stdlib.h>
#include<limits.h>
int sunsetmax_mul(int *a,int l,int r){
int i,temp,
nmax=0,//negtive max
pmax=0,//positive max
_max=a[l];
nmax=(_max<0 ? _max : 0);
pmax=(_max>0 ? _max : 0);
for(i=l+1;i<=r;i++){
if(a[i] < 0){
temp=pmax;
pmax=nmax==0 ?  0 : nmax*a[i];
nmax=temp==0 ?a[i]: temp*a[i];
}
else if(a[i] > 0){
pmax=pmax==0 ? a[i]: pmax*a[i];
nmax=nmax==0 ?   0 : nmax*a[i];
}
else {
pmax=nmax=0;
}
if(pmax > _max) _max=pmax;
}
return _max;
}
int main(){
int a[]={-2,2,2,-5,2/*,5,-3,4,-6,-7,1,8,-3,5,9*/};
printf("max mul subset result is %d\n",sunsetmax_mul(a,0,4));
}

其他思想：
另一种思路（包括最大子数组的积）

求不相交两个子数组的最大和