最大子数组问题——编程珠玑第八章

问题：给定数组a[n]，求其子数组的最大和。例如输入数组为：

1，-2，3，10，-4，7，2，-5

和最大的子数组为3，10，-4，7，2，因此输出为18.

没有想到更“巧妙”的算法前，用所谓“暴力”算法一般都能解决：

1、简单算法：

       求出每个子数组的和，记录最大的那个即可。

void    maxSum_1(int a[], int n)
{
    int sum=NM,m=NM;//NM是一个很小的负数，例如-99999999.下同
    for(int i=0; i<n; i++)
    {
        sum=0;
        for(int j=i; j<n; j++)
        {
            sum += a[j];
            m = max(m,sum);
        }
    }
    cout<<__FUNCTION__<<" : "<<m<<endl;
}

算法复杂度是O(n²).书中的算法还有一个O(n³)的，比上面这个复杂之处是求sum时再从头开始，此处就不再提了。

2、分治法

       把数组分成均等的两段l和u，那么原问题的解就是：最大子数组要么在l中，要么在u中，要么横跨l和u。

横跨中点时的情况比较难理解：这时左面不再是求最大子数组，而是从中间向两边求最大和。

int    maxSum_2_helper(int a[], int l, int u)
{
    if(l>u)     return  NM;		//非法参数
    if(l==u)    return  a[l];		//只有一个元素
    int m = (l+u)/2 ;
    ///求左面一半的连续最大和
    int lmax=NM;
    for(int i=m,s=0; i>=l; i--)///从中点到最左端
    {
        s += a[i];
        lmax = max(lmax,s);
    }
    ///求右面一半的连续最大和
    int rmax=NM;
    for(int i=m+1,s=0; i<=u; i++)
    {
        s += a[i];
        rmax = max(rmax,s);
    }
   ///合并结果
   ///rlm是左右子数组中的最大子数组的和
    int rlm = max(maxSum_2_helper(a,l,m), maxSum_2_helper(a,m+1,u)) ;
    return  max(rlm,lmax+rmax);///合并跨越中点的和两边的最大和
}

void    maxSum_2(int a[], int n)
{
    int m=maxSum_2_helper(a,0,n-1);
    cout<<__FUNCTION__<<" : "<< m <<endl;
}

该算法非常微妙，其复杂度是O(nlogn).

3、巧妙的扫描算法

       考虑如果我们已经求得a[0…i-1]的最大子数组和为m，那么a[0…i]的最大子数组要么在0~i-1中（存储在maxSoFar），要么截止到i（存储在maxEndingHere）。

void    maxSum_3(int a[], int n)
{
    int maxSoFar=NM, maxEndingHere=NM;
    for(int i=0; i<n; i++)
    {
        maxEndingHere = max(maxEndingHere+a[i], a[i]);
        maxSoFar = max(maxSoFar,maxEndingHere);
    }
    cout<<__FUNCTION__<<" : "<< maxSoFar <<endl;
}

这个算法的另一种形式：

void    maxSum_3_2(int a[], int n)
{
    int m=NM, sum=0;
    for(int i=0; i<n; i++)
    {
        sum += a[i];
        m = max(m,sum);
        if(sum<0)
            sum = 0;
    }
    cout<<__FUNCTION__<<" : "<< m <<endl;
}

相关问题：

a)查找总和最接近0的连续子数组，更一般的情况，查找最接近给定实数t的连续子数组。

       如果a[i…j]最接近0，那么a[0…i]的和就与a[0…j]的和最接近。所以使用累加数组即可。由原数组构造新数组s[n]（或者直接在原数组上操作），使s[i]=sum(a[0…i])。然后对s[n]排序，求出s[n]中最接近的两个数。这两个数的差值即为最接近0的子数组和。需要说明的是，这时需要新建数据结构，记录原来数组中每个元素的位置。

由于排序最快为O(nlogn),因此这个时间复杂度O(nlogn)，空间O(n).

代码如下，使用stl的排序函数sort。

struct   AP
{
    int value;
    int pos;
};
bool    operator<(const AP & n, const AP &m)
{
    return  n.value<m.value;
}

template  <typename T>
inline  T   abs(T n)
{
    return  n<0?(-n):n;
}

int    nearZero(int a[], int n)
{
    AP *b=new AP[n]();
    int sum=0;
    for(int i=0;i<n;i++)
    {
        b[i].pos = i;
        sum += a[i];
        b[i].value = sum;
    }
    sort(b,b+n);
    ///寻找差绝对值最小的两个元素
    int dmin=NM;
    int t = 0;
    for(int i=1; i<n; i++)
    {
        if( abs(dmin) > abs(b[i].value - b[i-1].value))
        {
            dmin = abs(b[i].value - b[i-1].value);
            t = i;
        }
    }
    ///t 和 t-1 位置元素之差极为最接近0
    int r=NM;
    int s,e;///s为子数组起始下表，e为子数组末尾下表
    if(b[t].pos<b[t-1].pos)
    {
        r = b[t-1].value - b[t].value;
        s = b[t].pos + 1;
        e = b[t-1].pos;
    }
    else
    {
        r = b[t].value - b[t-1].value;
        s = b[t-1].pos + 1;
        e = b[t].pos;
    }
    cout<<__FUNCTION__<<" : "<< r <<endl;
    cout<<"["<<s<<","<<e<<"]"<<endl;

    delete [] b;
    return r;
}

     对于任意实数的问题，目前还没想到合适的解法。开始觉得对数组中每个元素平移是一个貌似可行的解决方法，但是仔细分析后发现是不行的。

  后序还有最大子矩阵问题。

未完待续。

参考：http://www.cnblogs.com/wuyuegb2312/p/3139925.html