最大子序列和问题

问题：任意给定一序列，求解连续子序列的最大和。

算法一：最简单粗暴的解法，把所有可能的情况简单遍历。如果序列长度为n,设和最大的子序列为[i,j]，i从0到n遍历，j从i到n遍历，和为数组元素下标为i~j的累加，时间复杂度为O（n^3).

//立方算法
int MaxSubSepSum(int *a, int n)
{
    int MaxSum = 0;
    for(int i = 0; i < n; ++i)
    {
        for(int j = i; j < n; ++j)
        {
            int  TmpSum = 0;
            for(int k = i; k <= j; ++k)
                TmpSum += a[k];
            if(TmpSum > MaxSum)
                MaxSum = TmpSum;
        }
    }
    return MaxSum;
}

算法二：立方算法中求和有很多重复计算，通过保存中间状态减小计算量，下面是两个平方算法，时间复杂度O(n^2)。

//平方算法1
int MaxSubSepSum(int *a, int n)
{
    int MaxSum = 0;
    for(int i = 0; i < n; ++i)
    {
        int TmpSum = 0;
        for(int j = i; j < n; ++j)
        {
            TmpSum += a[j];
            if(TmpSum > MaxSum)
                MaxSum = TmpSum;
        }
    }
    return MaxSum;
}

//平方算法2
int MaxSubSepSum(int *a, int n)
{
    int *SumOfZero2i = new int[n];
    SumOfZero2i[-1] = 0;
    for(int i = 1; i < n; ++i)
        SumOfZero2i[i] = SumOfZero2i[i-1] + a[i];
    int MaxSum = 0;
    for(int i = 0; i < n; ++i)
    {
        for(int j = i; j < n; ++j)
        {
            int Sum = SumOfZero2i[j] - SumOfZero2i[i-1];
            if(Sum > MaxSum)
                MaxSum = Sum;
        }
    }
    return MaxSum;
}

算法三：ShaMos设计的利用分治思想的算法，把序列分为左半部分和右半部分，最大和要么出现在左半部分，要么出现在右半部分，要么横跨左右部分。前两种情况可以递归求解，第三种情况的最大和可以通过求出前半部分的最大和（包括前半部分的最后一个元素）以及后半部分的最大和（包含后半部分的第一个元素）相加得到。自己写这个算法的时候出现了死循环问题，问题在于数组长度不断减半，最后数组只剩一个时仍然划分为左右两部分造成的死循环，因此分治算法特别要注意边界，否则可能造成死循环。

时间复杂度： T(1) = 1;

  T(N) = 2T(N/2) + O(N)

   推出：T(N) = O(NlogN)

//分治算法
int Max3(int a, int b, int c)
{
    int d = a > b ? a : b;
    return d > c ? d : c;
}
    
int MaxSubSum(int *a, int start, int end)
{
    //不可少，不断二分最后数组只剩一个值，需单独判断，否则造成死循环
    if(start == end)
    {
        if(a[start] > 0)
            return a[start];
        else
            return 0;
    }
    int center = (end + start)/2;
    int MaxLeftSum = MaxSubSum(a, start, center);
    int MaxRightSum = MaxSubSum(a, center+1, end);
    int MaxLeftBorderSum = 0, MaxLeftTmpSum = 0;
    for(int i = center; i >= start; --i)
    {
        MaxLeftTmpSum += a[i];
        if(MaxLeftTmpSum > MaxLeftBorderSum)
            MaxLeftBorderSum = MaxLeftTmpSum;
    }

    int MaxRightBorderSum = 0, MaxRightTmpSum = 0;
    for(int i = center + 1; i <= end; ++i)
    {
        MaxRightTmpSum += a[i];
        if(MaxRightTmpSum > MaxRightBorderSum)
            MaxRightBorderSum = MaxRightTmpSum;
    }
    return Max3(MaxLeftSum, MaxRightSum, MaxLeftBorderSum + MaxRightBorderSum);
} 

int MaxSubSeqSum(int *a, int n)
{
    return MaxSubSum(a, 0 , n-1);
}

算法四：线性扫描算法，如果只扫描一趟，该如何设计算法呢?如果设最大子序列和MaxSum初始值为零，临时变量MaxTmpSum记录数组元素的累加和，如果MaxTmpSum大于MaxSum则替换MaxSum。但是遍历有可能舍弃前面的序列，重新累加一个新的子序列，什么时候舍弃呢？MaxSum初始值为零，如果累加和小于零那这一段序列就没有保留的必要了，因为它已经小于MaxSum的最小值零了，从新的位置开始求和。时间复杂度O(N)。

//线性扫描算法
int MaxSubSeqSum(int *a, int n)
{
    int MaxSum = 0, MaxTmpSum = 0;
    for(int i = 0; i < n; ++i)
    {
        MaxTmpSum += a[i];
        if(MaxTmpSum > MaxSum)
            MaxSum = MaxTmpSum;
        else if(MaxTmpSum < 0)
            MaxTmpSum = 0;
    }
    return MaxSum;
}