最大子段和 分治与动态规划

问题：
  给定n个整数（可能为负数）组成的序列a[1],a[2],a[3],…,a[n],求该序列如a[i]+a[i+1]+…+a[j]的子段和的最大值。当所给的整均为负数时定义子段和为0，依此定义，所求的最优值为：
    Max{0,a[i]+a[i+1]+…+a[j]},1<=i<=j<=n
    例如，当（a1,a2,a3,a4,a4,a6）=(-2,11,-4,13,-5,-2)时，最大子段和为20。

问题求解：

方法一：枚举

学过程序设计的都会，那就是枚举i和j，求i和a[i]到a[j]之间的和的最大值。

时间复杂度O（n^3）。这显然是不能接受滴。其实这其中进行了大量的重复计算。

#include<iostream>
using namespace std;

/*简单算法:
**v[0]不保存数据
**T(n)=O(n^2).
*/
int MaxSum(int *v,int n,int *besti,int *bestj)
{
    int sum=0;
    int i,j;
    for (i=1;i<=n;i++)
    {
        int thissum=0;
        for (j=i;j<=n;j++)
        {
            thissum+=v[j];
            if (thissum>sum)
            {
                sum=thissum;
                *besti=i;
                *bestj=j;
            }
        }
    }
    return sum;
}

int main(void)
{
    int n,m,i,j,k=0;
    int arr[100];
    cin>>n;
    m = n;
    while(n--)
    {
        cin>>arr[k++];
    }
    int r = MaxSum(arr,m,&i,&j);
    cout<<i<<" "<<j<<endl;
    cout<<r<<endl;
    return 0;
}

方法二：分治

考虑能不能有O（n*logn）的算法呢？当然有了……

如果将给定的序列a[1..n]分成长度相等的两段a[1..n/2]和a[n/2+1:n]，分别求出这两段的最大字段和。则该给定序列的最大字段和有三种情行：

1）和a[1..n/2]的最大字段和相同。

2）和a[n/2+1:n]的最大字段和相同。

3）最大字段和包含两部分，一部分在中，另一部分在a[n/2+1..n]中。

前两种情形我们可以用递归方法求出，第三种情形可以分别求出两部分的最大字段和值再相加（注：a[1..n/2]这部分求最大字段和要以a[n/2]结束，a[n/2+1..n] 这部分求最大字段和要以a[n/2+1]开始）。序列的最大字段和即为这三种情形的最大值。

这种情况下，显然时间复杂度为O(n*logn)。要是有O（n）的算法该多好呢？事实上还真有。这自然就是要想到动态规划了吧！！！

#include<iostream>
using namespace std;

/*分治法:
**将a[1n]分成a[1n/2]和a[n/2+1n],则a[1n]的最大字段和有三种情况:
**(1)a[1n]的最大子段和与a[1n/2]的最大子段和相同
**(2)a[1n]的最大子段和与a[n/2n]的最大子段和相同
**(3)a[1n]的最大子段和为ai++aj,1<=i<=n/2,n/2+1<=j<=n
**T(n)=2T(n/2)+O(n)
**T(n)=O(nlogn)
*/
int MaxSum_DIV(int *v,int l,int r)
{
    int k,sum=0;
    if(l==r)
        return v[l]>=0?v[l]:0;
    else
    {
        int center=(l+r)/2;
        int lsum=MaxSum_DIV(v,l,center);
        int rsum=MaxSum_DIV(v,center+1,r);

        int s1=0;
        int lefts=0;
        for (k=center;k>=l;k--)
        {
            lefts+=v[k];
            if(lefts>s1)
                s1=lefts;
        }

        int s2=0;
        int rights=0;
        for (k=center+1;k<=r;k++)
        {
            rights+=v[k];
            if(rights>s2)
                s2=rights;
        }
        sum=s1+s2;
        if(sum<lsum)
            sum=lsum;
        if(sum<rsum)
            sum=rsum;
    }
    return sum;
}


int main(void)
{
    int n,m,i,j,k=0;
    int arr[100];
    cin>>n;
    m = n;//记录数组的长度
    while(n--)
    {
        cin>>arr[k++];
    }
    int r = MaxSum_DIV(arr,0,m);
    cout<<r<<endl;
    return 0;
}

方法三：动态规划

动态规划不太好理解

#include<iostream>
using namespace std;

int MaxSum_DYN(int *a,int n)
{
    int temp = 0,maxn = 0,k=1,i;
    int start,end;
    for(i=1;i<=n;i++)
    {
        temp+=a[i];
        if(temp>maxn)
        {
            maxn = temp;
            start = k;
            end = i;
        }
        if(temp<0)
        {
            temp = 0;
            k = i+1;
        }
    }
    
    return maxn;
}


int main(void)
{
    int n,m,i,j,k=0;
    int arr[100];
    cin>>n;
    m = n;//记录数组的长度
    while(n--)
    {
        cin>>arr[k++];
    }
    int r = MaxSum_DYN(arr,m);
    cout<<r<<endl;
    return 0;
}

 分析一下这个算法，借用了一个临时变量temp，其实有三种情况：

1. 若temp>maxn则更新maxn，并保存开始和结束位置；

2. 若temp<0则令temp = 0，因为temp<0则不可能继续用temp更新最大值了；

3. 若0<temp<maxn，则不作操作，这是temp被认为是有潜力的，可能会用来更新后面的值。这样的一次遍历搜索到了所有的最大值。

（temp的使用时关键，好好理解这种思想。理解不了也没关系，这是比较难想的方法。）

 编程珠玑上的经典题目，也已经被做烂了，除了最后一个方法，其他的都是浮云，但是最后一个方法写得也比较啰嗦，k完全没必要。

int Sum(int* a, int n)
{
    int curSum = 0;
    int maxSum = 0;

    for (int i = 0; i < n; i++)
    {
        if (curSum + a[i] < 0)
            curSum = 0;
        else
            maxSum = max(maxSum, curSum += a[i]);
    }
    return maxSum;
}