最大子列和问题

问题描述：给定K个整数组成的序列{ N​1​​, N​2​​, ..., N​K​​ }，“连续子列”被定义为{ N​i​​, N​i+1​​, ..., N​j​​ }，其中 1≤i≤j≤K。“最大子列和”则被定义为所有连续子列元素的和中最大者。例如给定序列{ -2, 11, -4, 13, -5, -2 }，其连续子列{ 11, -4, 13 }有最大的和20。现要求你编写程序，计算给定整数序列的最大子列和。

1.穷举法：时间复杂度O(n^3)

穷举法，计算了所有可能性，时间复杂度O(n^3)。

int MaxSubseqSum1(int a[],int size)
{
    int ThisSum,MaxSum=0;
    for(int i = 0;i < size;i++)
        for(int j = i;j < size;j++)
        {    
            ThisSum = 0;
            for(int k = i;k <= j;k++)
                ThisSum += a[k];
            if(MaxSum < ThisSum)
                MaxSum = ThisSum;
        }
    return MaxSum;
}

2.算法二：时间复杂度O(n^2)

在穷举法的基础上略有改进，少了一重for循环，效率有所提高，代码简单易懂。

int MaxSubseqSum2(int a[],int size)
{
    int ThisSum,MaxSum=0;
    for(int i = 0;i < size;i++)
    {
        ThisSum = 0;
        for(int j = i;j < size;j++)
        {
            ThisSum += a[j];
            if(MaxSum < ThisSum)
                MaxSum = ThisSum;
        }    
    }
    return MaxSum;
}

3.分而治之：时间复杂度O(nlogn)

采用递归的思想。最大子列和有三种情况，左边最大子列和，右边最大子列和，跨越中间的最大子列和,取三之大者。递归到最后即，两个数，比较左数右数或他们的和，取大。

//分而治之 
int MaxSubseqSum3(int a[],int size)
{
    return MaxSum(a,0,size-1);
}

int MaxSum(int a[],int left,int right)
{
    if(left == right)
        return a[left] > 0 ? a[left] : 0;
    int center = (left + right) / 2; 
    int MaxLeftSum = MaxSum(a,left,center);
    int MaxRightSum = MaxSum(a,center+1,right);
    //求左边界最大值 
    int Centerto_Left = 0,MaxSum_Centerto_Left = 0;
    for(int i = center;i >= left;i--){
        Centerto_Left += a[i];
        if(MaxSum_Centerto_Left < Centerto_Left)
            MaxSum_Centerto_Left = Centerto_Left;
    }
    // 求右边界最大值
    int Centerto_Right = 0,MaxSum_Centerto_Right = 0;
    for(int i = center+1;i <= right;i++){
        Centerto_Right += a[i];
        if(MaxSum_Centerto_Right < Centerto_Right)
            MaxSum_Centerto_Right = Centerto_Right;
    }
    return MaxSum3(MaxLeftSum,MaxRightSum,MaxSum_Centerto_Left + MaxSum_Centerto_Right);
}
int MaxSum3(int a,int b,int c)
{
    return (a>b?a:b)>c?(a>b?a:b):c; 
}

 4.在线处理：时间复杂度O(n)

在线处理的规则是，从头开始求子列和，并记录当前最大子列和，若当前子列和为负，则抛弃之。代码很清楚的说明了这一规则。

个人认为在线处理的理解核心：当前子列和若为正，总有可能使之后的子列和变大的。如果当前子列和为负，则不可能是后面的子列和变大，所以抛弃。

//在线处理
int MaxSubseqSum4(int a[],int size)
{
    int ThisSum=0,MaxSum=0;
     for(int i = 0;i < size;i++){
         ThisSum += a[i];
        if(MaxSum < ThisSum)
             MaxSum = ThisSum;
        else if(ThisSum < 0)
            ThisSum = 0;
    }
    return MaxSum;
}

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　整理自Mooc陈越 、何钦铭数据结构课程