连续子数组的最大和

题目：输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。求所有子数组的和的最大值。要求时间复杂度为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 arrayunsigned int nLength, // the length of arrayint &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);    }}