最大子段和问题

给定n个整数（可能为负整数）a1,a2,a3……an.求形如 ai,a(i+1),……，aj i,j=1,……n,i<=j
的子段和的最大值。当所有的整数均为负整数的时候定义其最大子段和为0，例如：当（a1,a2,a3,a4,a5,a6）=(-2,11,-4,13,-5,-2)时，最大子段和为 i=2,j=4(下标从1开始)。

一、枚举法解决

枚举所有可能的起始下标（i=1,2,3,……，n）和终止下标（j=i,i+1……,j）,累加i到j所有元素的和，并从中选取最大的子段和。

partsum()
{
    int i,j,n,t,a[100];
    print("input number of data(<99):");
    input(n);
    print("input",n,"data:");
    for(i=1;i<=n;i++)
    {
        input(a[i]);
    }
    i=j=1;
    t=max_sum(a,n,&i,&j);
    print("The most sum of section is",t);
    print("starting point is",i);
    print("end point is",j);
}
max_sum(int a[],int n,int *best_i,int *best_j)
{
    int i,j,k,this_sum,sum;
    sum=0;
    *best_i=0;
    *best_j=0;
    for(i=1;i<=n;i++) 
    {
        for(j=1;j<=n;j++) 
        {
            this_sum=0;
            for(k=i;k<=j;k++) 
            {
                this_sum = this_sum+a[k];
            }
            if(this_sum>sum)
            {
                sum=this_sum;
                *best_i=i;
                *best_j=j;
            }
        }
    }
    return sum;
}

二、分治算法解决

如果将所给的序列a[1:n]分为长度相同的两段a[1:n/2]和a[(n/2)+1:n]，分别求出这两段的最大子段和，则a[1:n]的最大子段和有三种情形。
（1）a[1:n]的最大字段和与a[1:n/2]的最大字段和相同
（2）a[1:n]的最大字段和与a[(n/2)+1:n]的最大字段和相同
（3）a[1:n]的最大子段和为a[i:j],且1<=i<=(n/2),(n/2)+1<=j<=n
（1）和（2）可递归求得，对于（3）而言，序列中的元素a[(n/2)]与a[(n/2)+1]一定在最大字段中。因此，可以计算出a[i：(n/2)]的最大值s1;并计算出a[(n/2)+1:j]中的最大值s2.则s1+s2即为（3）的最优值。

partsum()
{
    int i,j,n,t,a[100];
    print("input number of data(<99):");
    input(n);
    print("input",n,"data:");
    for(i=1;i<=n;i++)
    {
        input(a[i]);
    }
    i=j=1;
    t=max_sum(a,n,&i,&j);
    print("The most sum of section is",t);
    print("starting point is",i);
    print("end point is",j);
}
int max_sum(int a[],int n)
{
    return max_sub_sum(a,1,n);
}
max_sub_sum(int a[],int left,int right)
{
    int center,i,j,left_sum,right_sum,sum,s1,s2,lefts,rights;
    if(left=right)
    {
        if(a[left]>0)
        {
            return a[left];
        }
        else
        {
            return 0;
        }
    }
    else
    {
        center=(left+right)/2;
        left_sum=max_sub_sum(a,left,center);
        right_sum=max_sub_sum(a,center+1,right);
        s1=0;//情形（3）的处理
        lefts=0;
        for(i=center;i>=left;i--) 
        {
            lefts=lefts+a[i];
            if(lefts>s1)
            {
                s1=lefts;
            }
        }
        s2=0;
        rights=0;
        for(i=center+1;i<=right;i++) 
        {
            rights=rights+a[i];
            if(rights>s2)
            {
                s2=rights;
            }
        }
        if(s1+s2<left_sum and right_sum<left_sum) 
        {
            return left_sum;
        }
        if(s1+s2<right_sum) 
        {
            return right_sum;
        }
        return s1+s2;
    }
}

三、动态规划算法解决

用动态规划法解决问题的思路很简单，就是通过开辟存储空间，存储各个子问题的计算结果，从而避免重复的计算。其实就是用空间效率去换取时间效率。
记sum[i]为a[1]~a[i]的最大字段和，记this_sum[i]为当前子段和。
this_sum[i]从i=1开始计算，当this_sum[i-1]>=0时，前面字段的和对总和有贡献，所以要累加当前元素的值；当this_sum[i-1]<0时，前面字段的和对总和没有贡献，要重新开始累加，以后的子段和从i开始。sum[i]在记录a[1]~a[i]的最大字段和，不断存储新得到的较大的this_sum[i]。
初值：this_sum[0]=0； i=1,2……n时
this_sum[i]=this_sum[i-1]+a[i] ——> 当this_sum[i-1]>=0
this_sum[i]=a[i] ——> 当this_sum[i-1]<0
相应地sum[i]的递推式如下：a[0]=0,i=1,2……n时，
sum[i]=sum[i-1] ——> 当this_sum[i]<=sum[i-1]
sum[i]=this_sum[i] ——> 当this_sum[i]>sum[i-1]

partsum()
{
    int i,j,n,t,a[100];
    print("input number of data(<99):");
    input(n);
    print("input",n,"data:");
    for(i=1;i<=n;i++)
    {
        input(a[i]);
    }
    i=j=1;
    t=max_sum(a,n,&i,&j);
    print("The most sum of section is",t);
    print("starting point is",i);
    print("end point is",j);
}
max_sub_sum(int a[],int n,int *best_i,int *best_j)
{
    int i,j,this_sum[n+1],sum[n+1];
    this_sum[0]=0;
    *best_i=0;
    *best_j=0;
    i=1;
    for(j=1;j<=n;j++) 
    {
        this_sum[j] = this_sum[j-1]+a[j];
        if(this_sum[j]>sum[j])
        {
            sum[j]=this_sum[j];
            *best_i=i;
            *best_j=j;
        }
        else if(this_sum[j]<0)
            {
                i=j+1;
                this_sum[j]=0;
            }
    }
    return sum;
}

四、递推算法解决

在上述算法的空间上进行优化，存储a[1]~a[j]的当前子段和的this_sum及当前最大子段和的sum都不必设置为n个元素的数组，用普通变量就可以实现了。因为在递推的过程中，只需保存一个值就足够了。

partsum()
{
    int i,j,n,t,a[100];
    print("input number of data(<99):");
    input(n);
    print("input",n,"data:");
    for(i=1;i<=n;i++)
    {
        input(a[i]);
    }
    i=j=1;
    t=max_sum(a,n,&i,&j);
    print("The most sum of section is",t);
    print("starting point is",i);
    print("end point is",j);
}
max_sub_sum(int a[],int n,int *best_i,int *best_j)
{
    int i,j,this_sum,sum;
    this_sum=0;
    *best_i=0;
    *best_j=0;
    i=1;
    for(j=1;j<=n;j++) 
    {
        this_sum = this_sum+a[j];
        if(this_sum>sum)
        {
            sum=this_sum;
            *best_i=i;
            *best_j=j;
        }
        else if(this_sum<0)
            {
                i=j+1;
                this_sum=0;
            }
    }
    return sum;
}