最大连续子序列和及其起始位置(未测试)

/******************************

问题描述：求一个序列中的最大连续子序列和以及起始位置。若全为负数，则返回0。

*******************************/

 

 

int start, end;

start = end = 0;

/******************************

算法名称：枚举法

简述：列举所有可能的序列，并求和。前缀相同的序列重复求和，

      违背了“同一个数最多计算一次”的原则，导致复杂度上升。

复杂度分析：T(N) =  =

时间复杂度：O()

******************************/

int Sum1(const int A[], int n)

{

    int i, j, k;

         int start, end;

    int ThisSum, MaxSum;

   

         MaxSum = 0;

    for(i = 0; i < n; i++) /* 确定序列的起始索引 */

        for(j = i; j < n; j++){ /* 确定序列的终止索引 */

            ThisSum = 0;

            for(k = i; k <= j; k++)  /* 遍历A[i]~A[j] */

                ThisSum += A[k];

            if(ThisSum > MaxSum){

                MaxSum = ThisSum;

                                     start = i;

                                     end = j;

                            }

        }

         return MaxSum;

}

 

/*****************************

算法名称：枚举法

简述：列举所有可能的序列。但在求和时，避免重复求和，复杂度降低。

算法分析：T(N) =  = ()/2

时间复杂度：O()

 

******************************/

int Sum2(const int A[], int n)

{

         int i, j;

         int ThisSum, MaxSum;

 

         MaxSum = 0;

         for(i = 0; i < n; i++){

                   ThisSum = 0;

                   for(j = i; j < n; j++){

                            ThisSum += A[j];        /* S(j) = A[j] + S(j-1) */

                            if(ThisSum > MaxSum){

                                     MaxSum = ThisSum;

                                     start = i;

                                     end = j;

                            }

                   }

         }

         return MaxSum;

}

 

/******************************

算法名称：分治递归法

简述：①每个序列的最大子序列有三个可能的位置：1、序列左半部；2、序列右半部；3、跨越序列左右半部分

           1、左半部，用递归求最大子序列和

           2、右半部，用递归求最大子序列和

           3、从中间元素开始，分别求左半部和右半部最大子序列和，然后求和

           ②base case：当所求序列只有一个元素时，若为正数，则返回该数，否则返回0。

           ③返回三个位置中最大的和。

复杂度分析：T(N) = 2T(N/2) + O(N)

时间复杂度：O(NlogN)

*******************************/

int Max3(int a, int b, int c)

{

         if(b > a)

                   a = b;

         if(c > a)

                   a = c;

         return a;

}

 

int SumSub3(const int A[], int left, int right)

{

         int center, i;

         int MaxLeftSum, MaxRightSum;

         int MaxLeftBorderSum, MaxRightBorderSum;

         int LeftBorderSum, RightBorderSum;

 

         if(left == right){               /* base case */

                   if(A[left] > 0)

                            return A[left];

                   else

                            return 0;

         }

 

         center = (left + right) / 2;

         MaxleftSum = SumSub3(A, left, center);      /* 左半部分的最大子序列 */

         MaxRightSum = SumSub3(A, center+1, right);  /* 右半部分的最大子序列 */

 

         MaxLeftBorderSum = 0; LeftBorderSum = 0;    /* 跨左右两部分的最大子序列的左半部分 */

         for(i = center; i >= 0; i--){

                   LeftBorderSum += A[i];

                   if(LeftBorderSum > MaxLeftBorderSum){

                            MaxLeftBorderSum = LeftBorderSum;

                            start = i;

                   }

         }

 

         MaxRightBorderSum = 0; RightBorderSum = 0; /* 跨左右两部分的最大子序列的右半部分 */

         for(i = center+1; i <= right; i++){

                   RightBorderSum += A[i];

                   if(RightBorderSum > MaxRightBorderSum){

                            MaxRightBorderSum = RightBorderSum;

                            end = i;

                   }

         }

 

         return Max3(MaxLeftBorderSum + MaxRightBorderSum, MaxleftSum, MaxRightSum);    /* 返回三种子序列中的最大值 */

}

 

int Sum3(const int A[], int n)

{

         return SumSub3(A,0, n-1);

}

 

/*********************************

算法名称：线性联机算法

简述：重要思想:任何和为负数的子序列都不可能是最大子序列的前缀。

若A[i] 为负数，则A[i] 不可能是最大子序列的前缀，同理，即若A[i] 到A[j]的j-i+1个元素的和为负数，则应将其抛弃，重新求和。

在A[j]之前可能有最大和，会保存在MaxSum中，而ThisSum则重新求和(求和)。

复杂度分析：时间复杂度为O(N)，线性。

                            每次读取一个元素后，不需要存储，直接加到ThisSum上。

                            而且此算法在任何时刻都能对已读取数据给出当前数据的解。联机算法。

常量空间线性时间的联机算法几乎是完美的算法。

**********************************/

int Sum4(const int A[], int n)

{

         int ThisSum, MaxSum;

         int i;

 

         ThisSum = MaxSum = 0;

         for(i = 0; i < n; i++){

                   ThisSum += A[i];

                   if(ThisSum > MaxSum){

                            MaxSum = ThisSum;

                            end = i;

                   }

                   else if(ThisSum < 0)   /* 当前子序列的和为负，则应重新求和 */

                            ThisSum = 0;

                            start = i+1;

         }

 

         return MaxSum;

}

转载于:https://www.cnblogs.com/ithink/p/max_subsequence_sum.html