浙大数据结构最大子列和问题（分而治之、在线处理算法）

最新推荐文章于 2021-08-10 13:24:56 发布

Scarlett_ma

最新推荐文章于 2021-08-10 13:24:56 发布

阅读量1.8k

点赞数 7

分类专栏：数据结构文章标签：数据结构

数据结构专栏收录该内容

2 篇文章 0 订阅

订阅专栏

转载自https://blog.csdn.net/jimtrump/article/details/72782852

问题描述：

问题分析：

对于一般的问题，原始解都能通过一种蛮力算法，即穷举法的思想得到。这题也不例外。
如果我们，把输入的数组，所有的子列都历遍，并从中找出最大，即可得出我们的算法。也就是版本一。

学习要点：

1、如何寻找代码中的可改进点
2、通过改进代码，得到更有效的算法
3、了解在线处理和分而治之思想

int MaxSubSequm1(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;               //*
            for (k = i; k <= j; k++)   //*
                ThisSum += A[k];       //*
            if (ThisSum>MaxSum)  // 如果刚得到的子列和更大
                MaxSum = ThisSum; // 更新结果

        }

    }// 循环结束
    return MaxSum;   
}

然而,

  T(N)= O(N^3）    不能让人接受！

思考改进点

1、从历遍的方法？是不是一定要用 3 个 for ? 每个for 的作用是什么？
2、能不能通过动态规划，增加记录的思想，来减少循环？
3、问题的本质是什么？
3、可不可以考虑另外一种解法？

改进点一：通过改变记录方式，减少一个for 循环

标记有×× 的是可改进的代码


int MaxSubSequm1(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 +=A[j];               //*
                  // 对于相同i ,的不同j ,只要在j-1次循环的基础上累加1 项即可

            if (ThisSum>MaxSum)  // 如果刚得到的子列和更大
                MaxSum = ThisSum; // 更新结果

        }

    }// 循环结束
    return MaxSum;   
}

算法复杂度是吓人的 N^2

在线处理思想

改进点二：深入问题的本质：极端化

其实，我们注意到，
1、如果全部序列都为正数，即最大子列和就是其自身
2、如果最大子列全部为负数，那么最大子列和就是最小的负数
3、根据1,2 我们有，只有当前子列为正数时，才能使最大子列和增大。
于是，我们可以通过抛弃负子列，保证最大子列和递增。当扫描一遍，最大子列和不再递增时，当前的最大子列和即为我们的解。

在线处理

在线的意思是指每输入一个数据就进行即是处理，在任何一个地方终止输入，算法都能能正确给出当前解


int MaxSubseqSum4(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; // 发现更大和则更新当前结果
        else if (ThisSum < 0)  // 如果当前子列和为负数
            ThisSum = 0; // 则不可能使后面部分和增大，抛弃之
    }
    return MaxSum;

}

#另一种思想：分而治之

    int Max3( int A, int B, int C )
    { /* 返回3个整数中的最大值，注计算机会自动把满足三目表达式的看做一个整体 */
        return A > B ? A > C ? A : C : B > C ? B : C;
    }

    int DivideAndConquer( int List[], int left, int right )
    { /* 分治法求List[left]到List[right]的最大子列和 */
        int MaxLeftSum, MaxRightSum; /* 存放左右子问题的解 */
        int MaxLeftBorderSum, MaxRightBorderSum; /*存放跨分界线的结果*/

        int LeftBorderSum, RightBorderSum;
        int center, i;

        if( left == right )  { /* 递归的终止条件，子列只有1个数字 */
            if( List[left] > 0 )  return List[left];
            else return 0;
        }

        /* 下面是"分"的过程 */
        center = ( left + right ) / 2; /* 找到中分点 */
        /* 递归求得两边子列的最大和，注：递归算法经过return会挑出当前递归，返回上一层递归 */
        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 )
    { /* 保持与前2种算法相同的函数接口 */
        return DivideAndConquer( List, 0, N-1 );
    }