解决最大子列和问题的6种算法

最新推荐文章于 2023-01-03 19:45:20 发布

C小C

最新推荐文章于 2023-01-03 19:45:20 发布

阅读量1.2k

点赞数 4

分类专栏：数据结构文章标签：最大子列和问题在线处理动态规划分治

本文链接：https://blog.csdn.net/C_chuxin/article/details/84887398

版权

数据结构专栏收录该内容

2 篇文章 0 订阅

订阅专栏

【时间】2018.12.07

【题目】解决最大子列和问题的5种算法

概述

本文的主要内容来自于对中国慕课MOOC中浙大《数据结构》课程中的1.3节的整理。最大子列和问题是给定一个N长度的序列，求出它的最大子列和。本文中用于验证的主函数为：

#include <stdio.h>

#define MAXN 100000    

int main(void) {

    int K, i;

    int a[MAXN] = {0};

    
    scanf_s("%d", &K);

    for ( i = 0; i < K; i++ )

        scanf_s("%d", &a[i]);

    printf("%d", MaxSubseqSum1( a, K ));    //不同方法此处修改函数名即可。

    

    return 0;

}

一、方法一：暴力破解------O（N^3)

暴力破解使用穷举法。简单来说，我们只要用两层循环枚举起点和终点，这样就尝试了所有的子序列，然后在用一层循环计算每个子序列的和，然后找到其中最大的即可。

int MaxSubseqSum1 ( int A[], int N ) {

    int ThisSum, MaxSum = 0;

    int i, j, k;

    

    for ( i = 0; i < N; i++ ) {    //i是子列左端位置。

        for ( j = i; j < N; j++ ) {    //j是子列右端位置。

            ThisSum = 0;    //    每轮都要把ThisSum归零，累加新一轮的子列和。

            for ( k = i; k < j; k++ )    //将A[i]~A[j]累加，得到子列和。

                ThisSum += A[k];

            if ( ThisSum > MaxSum )    //如果这轮的子列和比最大子列和还大，存入MaxSum.

                MaxSum = ThisSum;

        }

    }

    

    return MaxSum;

}

【运行结果】

二、方法二：二重循环----O（N^2)

改进点：对于相同的子列左端位置 i ，不同的右端位置 j ，我们只要每次在右端累加一项，即可求得每一个子列和。这样就可以减少一层循环。

int MaxSubseqSum2 ( int A[], int N ) {

    int ThisSum, MaxSum = 0;

    int i, j;

    

    for ( i = 0; i < N; i++ ) {    //i是子列左端位置。

        ThisSum = 0;    //A[i]~A[j]的子列和。

        for ( j = i; j < N; j++ ) {    //j是子列右端位置。

            ThisSum += A[j];    //对于相同的i，不同的j，只要在j-1处再累加1项即可。

        if ( ThisSum > MaxSum )    //更新MaxSum.

            MaxSum = ThisSum;

        }

    }

    

    return MaxSum;

}

三、使用分治算法-----O（NlogN)

基本思路：

将序列从中间分为左右两个子序列。
递归求得两个子列的最大和。
从中分点分头向左、右两边扫描，找出跨过分界线的最大子列和。
输出这三个子列和最大的一个。

【注意】递归终止的条件是子序列的左端==右端，即子序列只有一个数的时候。

【代码】：

/*返回三个整数的最大值*/

int Max3 ( int A, int B, int C ) {

    return (A > B) ? (A > C ? A : C) : (B > C ? B : C);

}

/*分治法球List[left]到List[right]的最大子列和*/

int DivideAndConquer ( int List[], int left, int right ) {

    int MaxLeftSum, MaxRightSum;    //存放左右子问题的解。

    int MaxLeftBorderSum, MaxRightBorderSum;    //存放跨分界线的结果。

    

    int LeftBorderSum, RightBorderSum;

    int center, i;

    

    /*递归的终止条件，子列只有1个数字*/

    if ( left == right ) {

        if ( List[left] > 0 )    return List[left];

        else return 0;

    }

    

    /* “分”的过程 */

    center = ( left + right ) / 2;    //找到中分点。

    MaxLeftSum = DivideAndConquer ( List, left, center );    //递归求左子列和。

    MaxRightSum = DivideAndConquer ( List, center+1, right );    //递归求右子列和。

    

    /*求跨分界线的最大子列和*/

    MaxLeftBorderSum = 0;    LeftBorderSum = 0;

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

        LeftBorderSum += List[i];

        if ( LeftBorderSum > MaxLeftBorderSum )

            MaxLeftBorderSum = LeftBorderSum;

    }//左边扫描结束。

    

    MaxRightBorderSum = 0;    RightBorderSum = 0;

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

        RightBorderSum += List[i];

        if ( RightBorderSum > MaxRightBorderSum )

            MaxRightBorderSum = RightBorderSum;

    }//右边扫描结束。

    

    /*返回“治”的结果*/

    return Max3 ( MaxLeftSum, MaxRightSum, MaxLeftBorderSum + MaxRightBorderSum );

}

/*此函数用于保持接口相同*/

int MaxSubseqSum3 ( int List[], int N ) {

    return DivideAndConquer ( List, 0, N-1 );

}

四、在线处理----O（N）

所谓在线的意思，是指每输入一个数据就进行即时处理，这样，在任何一个地方中止输入，算法都能给出当前的正确解。这里用到了动态规划，很像数学中的递推。我们用dp[n]表示以第n个数结尾的最大连续子序列的和，于是存在以下递推公式：

dp[n] = max(0, dp[n-1]) + num[n]

【代码1】

int MaxSubseqSum4( int A[], int N ) {

    int ThisSum, MaxSum, i;

    ThisSum = MaxSum = 0;

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

          ThisSum += A[i]; /* 向右累加 */

          if( ThisSum > MaxSum )

                  MaxSum = ThisSum; /* ·发现更大和则更新当前结果 */

          else if( ThisSum < 0 ) /* 如果当前子列和为负数 */

                  ThisSum = 0; /* 则不可能使后面的部分和增大，抛弃之 */

    }

    return MaxSum;  

}

【代码2】递推式的实现

int MaxSubseqSum3(int A[], int N) {

       int ThisSum, MaxSum, i;

       ThisSum = A[0];

       MaxSum = (ThisSum > 0) ? ThisSum : 0;

       for (i = 1; i < N; i++) {

              if (ThisSum > 0)

                     ThisSum += A[i];

              else

                     ThisSum = A[i];   //实现递推式dp[n] = max(0, dp[n-1]) + num[n]

                     if (ThisSum > MaxSum)

                           MaxSum = ThisSum; /* ·发现更大和则更新当前结果 */

       }

       return MaxSum;

}

五、另一个在线处理算法----O（N）

思路：以第n个数为结尾的最大子序列和有什么特点？假设这个子序列的起点是m，于是结果为sum[n] - sum[m-1]。并且，sum[m-1]必然是sum[1],sum[1]...sum[n]中的最小值！这样，我们如果在计算sum数组的时候，同时保存之前的最小值lmin，那么只要计算sum[n] -lmin即可得到最大子序列和！

代码：

int MaxSubseqSum5(int A[], int N) {

       int ThisSum, MaxSum, i,lmin;

       ThisSum = MaxSum = lmin = 0;

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

              ThisSum += A[i];

              if (ThisSum < lmin)

                     lmin = ThisSum;

              if ((ThisSum - lmin) > MaxSum)

                     MaxSum = ThisSum - lmin;

       }

       return MaxSum;

}

参考链接：https://blog.csdn.net/YelloJesse/article/details/82312659

https://www.cnblogs.com/conw/p/5896155.html