连续子数组的最大和

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

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

如果不考虑时间复杂度，我们可以枚举出所有子数组并求出他们的和。

int MaxSum(vector<int>& coll)
{
    int maximum = -INF;
    int sum(0);
    for (int i = 0; i < coll.size(); i++)
    {
        for (int j = i; j < coll.size(); j++)
        {
            for (int k = i; k <= j; k++)
            {
                sum += coll[k];
                if (sum>maximum)
                {
                    maximum = sum;
                }
            }
        }
    }
}

不过非常遗憾的是，由于长度为n的数组有O(n2)个子数组；而且求一个长度为n的数组的和的时间复杂度为O(n)。因此这种思路的时间是O(n3)。

如果注意到sum[i,...,j]=sum[i,...,j-1]+a[j],则可以将算法中的最后一个for循环省略，避免重复计算，从而使算法得以改进。

int MaxSum(vector<int>& coll)
{
    int maximum = -INF;
    for (int i = 0; i < coll.size(); i++)
    {
        int sum = 0;
        for (int j = i; j < coll.size(); j++)
        {
            sum += coll[j];
            if (sum>maximux)
            {
                maximum = sum;
            }
        }
    }
    return maximum;
}

上面即用枚举法求出数组的所有子数组并求出它们的和，一个长度为n的数组，总共有n(n+1)/2个子数组。计算出所有子数组的和，最快也需要O(n2)的时间。通常最直观的方法不会是最优的方法。

我们这样理解，当我们加上一个正数时，和会增加；当我们加上一个负数时，和会减少。如果当前得到的和是个负数，那么这个和在接下来的累加中应该抛弃并重新清零，不然的话这个负数将会减少接下来的和。基于这样的思路，我们可以写出如下代码。

/
// Find the greatest sum of all sub-arrays
// Return value: if the input is valid, return true, otherwise return false
/
bool FindGreatestSumOfSubArray
(
int *pData,           // an array
unsigned int nLength, // the length of array
int &nGreatestSum     // the greatest sum of all sub-arrays
)
{
    // if the input is invalid, return false
    if ((pData == NULL) || (nLength == 0))
        return false;

    int nCurSum = nGreatestSum = 0;
    for (unsigned int i = 0; i < nLength; ++i)
    {
        nCurSum += pData[i];

        // if the current sum is negative, discard it
        if (nCurSum < 0)
            nCurSum = 0;

        // if a greater sum is found, update the greatest sum
        if (nCurSum > nGreatestSum)
            nGreatestSum = nCurSum;

    }
    // if all data are negative, find the greatest element in the array
    if (nGreatestSum == 0)
    {
        nGreatestSum = pData[0];
        for (unsigned int i = 1; i < nLength; ++i)
        {
            if (pData[i] > nGreatestSum)
                nGreatestSum = pData[i];
        }
    }

    return true;
}

或者这样写：

int findGreatestSumOfSubArray(vector<int>& coll)
{
    int curSum = 0;
    int GreatestSum = 0x80000000;
    for (int i = 0; i < coll.size(); i++)
    {
        if (curSum <= 0)
        {
            curSum = coll[i];
        }
        else
        {
            curSum += coll[i];
        }
        if (curSum > GreatestSum)
        {
            GreatestSum = curSum;
        }
    }
    return GreatestSum;
}

采用动态规划：

start[i] = max(A[i], start[i] + A[i])//以i为起点的从A[i]到A[n-1]的最大一段和
All[i] = max(start[i], All[i+1])//A[i]到A[n-1]中最大的一段和
int MaxSum(int* A, int n)
{
    start[n - 1] = A[n - 1];
    All[n - 1] = A[n - 1];
    for (int i = n - 2; i >= 0; i--)
    {
        start[i] = max(A[i], A[i] + start[i + 1]);
        All[i] = max(start[i], All[i + 1]);
    }
}

观察这两个递推式，其实都只须要用两个变量就可以了。start[i+1]只有在计算start[i]的时候使用，All[i+1]也只有在计算All[i]时使用，所以程序可以进一步改进一下，只需用O（1）的空间就足够了。

int MaxSum(int* A，int n)
{
    nstart = A[n - 1];
    nAll = A[n - 1];
    for (int i = n - 2; i >= 0; i--)
    {
        nStart = max(A[i], nstart + A[i]);
        nAll = max(nstart, nAll);
    }
    return nAll;
}

如果要求同时返回最大子数组的位置，则需要对算法作一些修改：

int MaxSum(int *A, int length, int& start, int& end){
    //ostart和oend用来标记当前最大子数组和nAll的起始跟终止位置  
    //start和end用来标记nStart的起始跟终止位置  
    int nStart = A[length - 1];
    int nAll = A[length - 1];
    start = end = length - 1;
    int ostart = start;
    int oend = end;
    for (int i = length - 2; i >= 0; i--){
        //如果A[i]>A[i]+nStart，说明nStart小于0，那么剔除这部分的值，
        //让A[i]为和最大的子数组的最后一个值，则有start=end=i  
        if (A[i]>A[i] + nStart){
            start = end = i;
            nStart = A[i];
        }
        else{
            //如果A[i]<A[i]+nStart，则说明nStart大于0，那么加入这部分使得A[i]+nStart比A[i]大，
            //则和最大的子数组的开始位置为i，结束位置不变  
            start = i;
            nStart = A[i] + nStart;
        }
        //如果nStart>nAll，说明nStart为当前和最大的子数组，因此赋值ostart=start;oend=end;  
        if (nStart>nAll){
            ostart = start;
            oend = end;
            nAll = nStart;
        }
    }
    start = ostart;
    end = oend;
    return nAll;
}

如果数组（A[0],....,A[n-1]首尾相邻），也就是我们允许找到一段数字（A[i],...A[n-1],A[0],...,A[j]),使其和最大，又该如何处理：

可以把问题的解分为两种情况：

1. 解没有跨过 A[n-1]到A[0]（原问题）。

2. 解跨过A[n-1]到A[0].

对于第二种情况，只要找到A[0]开始和最大的一段（A[0],...,A[j])（0<=j<n),以及以A[n-1]结尾的和最大的一段(A[i],...,A[n-1]),(0<=i<n),那么，第二种情况中，和的最大值M为：

M=A[i]+....+A[n-1]+A[0]+...A[j]

如果i小于j,则

M=A[0]+....A[n-1]

否则，

M=A[0]+.....A[j]+A[i]+....A[n-1]

最后，再取两种情况的最大值就可以了，求解A[n-1]到A[0]的情况只需要遍历数组一次，故总的时间复杂度为O（N）+O（N）=O(N)

/*********************************动态规划**************************************
假设A[0],A[1],...A(n-1)的最大子段为A[i],...,A[j]，则有以下3种情况，
1)当0=i=j的时候，元素A[0]本身构成和最大的一段
2)当0=i<j的时候，和最大的一段以A[0]开头
3)当0<i时候，元素A[0]跟和最大的一段没有关系
则原始问题A[0],A[1],...A(n-1)的解All[0]=max{A[0],A[0]+Start[1],ALL[1]}
求得A[0],A[1],...A[n-1](首尾不连接)的情况后再考虑整体思路中的第二种情况
*********************************************************************************/
//从尾到首动态规划  
int MaxSum(int *A, int length){
    //先求出A[0],A[1],...A[n-1](首尾不连接)的情况下子数组和最大值nAll  
    int nStart = 0;
    int nAll = 0;
    for (int i = length - 1; i >= 0; i--){
        nStart = max(0, A[i] + nStart);
        nAll = max(nStart, nAll);
    }
    //下面处理整体思路的第二种情况，即跨过A[n-1],A[0]  
    //先求A[n-1]结尾的和最大的一段(A[i],...,A[n-1])(0<=i<n)  
    int sum = 0;
    int ltempmax = -10000000;
    int lpos = length;
    for (int i = length - 1; i >= 0; i--){
        sum += A[i];
        if (sum>ltempmax){
            ltempmax = sum;
            lpos = i;
        }
    }

    //求A[0]开始和最大的一段(A[0],...,A[j])(0<=j<n)  
    sum = 0;
    int rtempmax = -10000000;
    int rpos = -1;
    for (int i = 0; i<length; i++){
        sum += A[i];
        if (sum>rtempmax){
            rtempmax = sum;
            rpos = i;
        }
    }

    //如果lpos<=rpos，则循环数组中可能出现的子数组最大值要么是A[0]...A[n-1]子数组和的最大值nAll  
    //要么是整个数组A[0]...A[n-1]的和再减去A[0]...A[n-1]中子数组和为负数的最小值  
    if (lpos <= rpos){
        //求数组中和为负数且的最小值  
        int minStart = 0;
        int minAll = 0;
        for (int i = 0; i<length; i++){
            minStart = min(0, A[i] + minStart);
            minAll = min(minStart, minAll);
        }
        int tempmax = ltempmax + rtempmax;
        for (int i = lpos; i <= rpos; i++){
            tempmax -= A[i];
        }
        //比较A[0]...A[n-1]子数组和的最大值nAll跟A[0]...A[n-1]的和再减去A[0]...A[n-1]中子数组和为负数的最小值  
        return max(nAll, tempmax - minAll);
    }
    else{
        //比较A[0]+...+A[j]+A[i]+...+A[n-1]即ltempmax+rtempmax的值跟A[0]...A[n-1]子数组和的最大值nAll  
        return max(nAll, ltempmax + rtempmax);
    }

}