最大连续子向量和

最大连续子向量和(一维模式识别)

问题描述：输入n个数，输出其中连续的几个数的最大和。

例如，如果输入数中包含以下10个元素，则输出x[2…6]的和，187

31 -41 59 26 -53 58 97 -93 -23 84

则从x[2]到x[6]的所有元素相加的值为最大连续子向量和。

解法1

基本思路：对数组进行扫描，设置i从0到n，设置j从i到n，然后累加从i到j的元素的和。通过打擂台的方法更新最大值，从而得到结果。这种方法需要经过三重循环，时间复杂度是O(n3)级别的。

int alg1(){
    int i,j,k;
    int sum,maxsofar=0;
    for(i=0;i<n;i++){
        for(j=0;j<n;j++){
            sum=0;
            for(k=i;k<=j;k++)	sum+=x[k];
            if(sum>maxsofar)	maxsofar=sum;
        }
    }
    return maxsofar;
}

解法2

基本思路：与解法1类似，也是设置i从0到n，j从i到n，不同的是这里不需要每次都计算从i到j中所有元素的和，而是每次经过一次循环后，把从0到当前位置所有元素的和计算出来，那么sum[i…j]=sum[j]-sum[i]。这里少了一层专门计算i到j中元素和的循环，所以时间复杂度降低为O(n2)级别的。

int alg2(){
    int i,j,k;
    int sum,maxsofar=0;
    for(i=0;i<n;i++){
        sum=0;
        for(j=i;j<n;j++){
            sum+=x[j];
            if(sum>maxsofar)	maxsofar=sum;
        }
    }
    return maxsofar;
}

int cumvec[MAXN+1]
int alg2b(){
    int i,j,k;
    int *cumarr,sum,maxsofar=0;
    cumarr=cumvec+1;//因为i的值会取到0，在这里加1，是为了i-1的值不会取到负数，取到负数会取到脏数据
    cumarr[-1]=0;
    for(i=0;i<n;i++)	cumaar[i]=cumarr[i-1]+x[i];
    for(i=0;i<n;i++){
    	for(j=i;j<n;j++){
    		sum=cumarr[j]-cumarr[i-1];
    		if(sum>maxsofar)	maxsofar=sum;
    	}
    }
    return maxsofar;
}

解法3

基本思路：在这里采用分治的思想。分治的思想是如果要解决规模为n的问题，可以递归的解决两个规模近似为n/2的子问题，然后对它们的答案进行合并来得到整个问题的答案。那么我们将这个向量x划分成两个近似相等的子向量a和b，分别找出a和b中的连续子向量最大和Ma和Mb，Ma和Mb中最大值可能是整个向量的连续最大子向量和，还有一种情况是划分的分界线正好在我们所求的连续子向量区间内。那么这种情况下这个M就可以由从n/2开始向前或向后计算子向量和，来取得最大和Mc。那么Mx=max(Ma,Mb,Mc),Mc=max(sum(x[i…n/2-1]))+max(sum(x[n/2…j]))

这里的时间复杂度是O(nlogn)级别的，计算和需要扫描是n级别的，分治则是logn级别的。

#define max(a,b) maxfun(a,b)
int maxfun(int a,int b){
    return a>b?a:b
}
int alg3(){
    return recmax(0,n-1);
}
int recmax(intl,int u){
    int i,m;
    int lmax,rmax,sum;
    if(l>u)	return 0;
    if(l==u)	return max(0,x[i]);
    m=(l+u)/2;
    lmax=sum=0;
    for(i=m;i>=l;i--){
        sum+=x[i];
        if(sum>lmax)	lmax=sum;
    }
    for(i=m+1;i<=u;i++){
        sum+=x[i];
        if(sum>rmax)	rmax=sum;
    }
    return max(lmax+rmax,max(recmax(l,m)),recmax(m+1,u));
}

解法4

基本思想：利用递归思想，假设现在已经解决了大小为(i-1)的向量x[0…i-2]的问题，那么如何计算大小为i的向量x[0…i-1]的问题呢？大小为i的向量x[0…i-1]中连续子向量中最大和Mi-1=max(Mi-2,maxendinghere[i-1])，其中maxendinghere[i-1]表示向量x[0…i-1]中结束位置为（i-1）的连续子向量的最大和，即maxendinghere[i-1]=max(sum(x[0…i-1]),sum(x[1…i-1])),…,sum(x[i-1…i-1])

然后再把递归改成循环来做，这里的时间复杂度是O(n)级别的。

int maxendinghereVec[MAXN+1]
int alg4(){
	int i;
	int maxsofar=0;
	int *maxendinghere=0;
	maxendinghere=maxendinghereVec+1;//同样是因为i可能取到0，为防止负溢出
	maxendinghere[-1]=0;
    for(i-0;i<n;i++){
    	maxendinghere[i]=maxendinghere[i-1]+x[i];
    	if(maxendinghere[i-1]<0)	maxendinghere[i-1]=0;
    	if(maxsofar<maxendinghere[i-1])	maxsofar=maxendinghere[i-1];
    }
    return maxsofar;
}