最大连续子序列和

给出一个数列，有正也有负，求其连续的一个子数列（不允许空序列），使它们的和最大。

1.复杂度O()

循环枚举起点和终点，这样尝试了所有的子序列，然后计算每个子序列的和，然后找到其中最大的。

2.复杂度O()

sum[i]表示第一个数到第i个数的和，第i个数到第j个数的和可以表示为sum[j]-sum[i-1](包括第i个数），这样可以省掉内层循环

int main()
{
    int n[1000],i,j,k,N,sum[1000],max=0;
    scanf("%d",&N);
    sum[0]=0;
    for(i=1;i<=N;i++)
    {
        scanf("%d",&n[i]);
        sum[i]=sum[i-1]+n[i];
    }
    max=n[1];
    for(i=1;i<=N;i++)
    {
        for(j=i;j<=N;j++)
        {
            k=sum[j]-sum[i-1];
            if(k>max)
            {
                max=k;
            }
        }

    }
    printf("%d",max);
    return 0;
}

3.复杂度O(N*logN)

采用分而治之的思想，当问题很复杂时，我们可以把问题划分为子问题，如果子问题规模还是太大，并且它还可以继续划分，那就继续划分下去。直到这些子问题已经很容易解决了，那么就把所有的子问题都解决，最后把所有的子问题合并，我们就得到复杂大问题的答案了。求最大子序列和时，把数列平均分为两部分，则只会有三种情况：

1）连续子序列全部出现在左边

2）连续子序列全部出现在右边

3）连续子序列一部分在左边一部分在右边

1，2种情况又可以按相同思路思考，所以可以使用递归解决，第三种情况分析如下：

以分割点为起点向左的最大连续序列和、以分割点为起点向右的最大连续序列和，左右两边最大连续序列和相加的结果就是第三种情况的答案。

#include <stdio.h>
#include <stdlib.h>
int num[1000];
int Sum(int left, int right)
{
    //序列长度为1时
    int i,max_left=0,max_right=0,mid,sum=0,max_l=0,max_r=0,max;
    if(left == right)
    {
        return num[left];
    }
    //划分为两个规模更小的子问题
    mid = (left + right)/2 ;
    max_left = Sum(left, mid);
    max_right = Sum(mid + 1, right);

    //横跨分割点的情况
    max_l = num[mid];
    max_r = num[mid + 1];
    for(i = mid; i >= left; i--)
    {
        sum += num[i];
        if(sum > max_l)
        {
            max_l = sum;
        }
    }
    sum=0;
    for(i = mid + 1; i <= right; i++)
    {
        sum += num[i];
        if(sum > max_r)
        {
            max_r = sum;
        }
    }

    //答案是三种情况的最大值
    max = max_l + max_r;
    if(max_left > max)
    {
        max = max_left;
    }
    if(max_right > max)
    {
        max = max_right;
    }
    return max;
}

int main()
{
    //输入数据
    int N,i;
    scanf("%d", &N);
    for(i = 1; i <= N; i++)
    {
         scanf("%d", &num[i]);
    }

    printf("%d\n", Sum(1, N));

    return 0;
}