最大子列和问题

题目来源：

https://pintia.cn/problem-sets/15/problems/709

问题描述： 

问题分析：

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

学习要点：

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;

}

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <vector>
#include <sstream>
#include <map>
#include <queue>
#include <stack>
#include <cstring>
#include <set>
using namespace std;


int k;
long long ans,tmp;
int a[100005];


int main()
{
    scanf("%d",&k);
    for(int i=0;i<k;i++)
    {
        scanf("%d",&a[i]);
    }
    for(int i=0;i<k;i++)
    {
        tmp+=a[i];
        if(tmp>ans)
        {
            ans=tmp;
        }
        if(tmp<0)
        {
            tmp=0;
        }
    }
    cout<<ans<<endl;
    return 0;
}

#另一种思想：分而治之

 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; /* 找到中分点 */
        /* 递归求得两边子列的最大和 */
        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 );
    }