求最大连续子数列和问题

点击此处倾听大佬教诲（就是看了这篇博文才明白的）

题目分析
给任意一串数字，求其中所有连续子列元素的和中最大者

题目拓展

1. 所有连续子列元素的差的最小者
2. 输出所求和或差的子列元素 （这个也没有想象中的那么难，确定起点与终点，用一个循环就ok了）

求解方法

1. 最简单粗暴的方法（思路：用两层循环枚举子列的起点和终点，从而找出最大的子列和。缺点是O(N^3)）

#include <stdio.h>

//N是数组长度，num是待计算的数组，放在全局区是因为可以开很大的数组
int N, num[1024];

int main()
{
    //输入数据
    scanf("%d", &N);
    for(int i = 1; i <= N; i++)
        scanf("%d", &num[i]);
    
    int ans = num[1]; //ans保存最大子序列和，初始化为num[1]能保证最终结果正确
    //i和j分别是枚举的子序列的起点和终点，k所在循环计算每个子序列的和
    for(int i = 1; i <= N; i++) {
        for(int j = i; j <= N; j++) {
            int s = 0;			//要清零，保证求的是i到j的序列和
            for(int k = i; k <= j; k++) {   //这个地方比较秀了，i与j相当于子列的起点与终点
                s += num[k];
            }
            if(s > ans) ans = s;
        }
    }
    printf("%d\n", ans);

    return 0;
}

2. 改进一下，利用数组sum[i]表示第1个到第i个数的和，由此可得第I个到第j个序列的和为sum[j]-sum[i-1]

#include <stdio.h>

//N是数组长度，num是待计算的数组，sum是数组前缀和，放在全局区是因为可以开很大的数组
int N, num[16384], sum[16384];

int main()
{
    //输入数据
    scanf("%d", &N);
    for(int i = 1; i <= N; i++)
        scanf("%d", &num[i]);
    
    //计算数组前缀和
    sum[0] = 0;
    for(int i = 1; i <= N; i++) {
        sum[i] = num[i] + sum[i - 1];
    }

    int ans = num[1]; //ans保存最大子序列和，初始化为num[1]能保证最终结果正确
    //i和j分别是枚举的子序列的起点和终点
    for(int i = 1; i <= N; i++) {
        for(int j = i; j <= N; j++) {
            int s = sum[j] - sum[i - 1];//主要是这里改变了，从而优化了算法
            if(s > ans) ans = s;
        }
    }
    printf("%d\n", ans);

    return 0;
}

3. 进一步优化，假设需要的子列是sum[n]-sum[m-1],显然sum[m-1]是sum[1],sum[2]…sum[n-1]中最小的一个，因此，在建立sum数组的时候，就可以确定这个“sum[m-1]”

#include <stdio.h>

//N是数组长度，num是待计算的数组，放在全局区是因为可以开很大的数组
int N, num[134217728];

int main()
{
    //输入数据
    scanf("%d", &N);
    for(int i = 1; i <= N; i++)
        scanf("%d", &num[i]);
    
    //计算数组前缀和，并在此过程中得到答案
    num[0] = 0;
    int ans = num[1], lmin = 0;
    for(int i = 1; i <= N; i++) {
        num[i] += num[i - 1];
        if(num[i] - lmin > ans)
            ans = num[i] - lmin;
        if(num[i] < lmin)
            lmin = num[i];//更新“sum[m-1]”
    }

    printf("%d\n", ans);

    return 0;
}

4. 分治法（函数递归实现）

#include <stdio.h>

//N是数组长度，num是待计算的数组，放在全局区是因为可以开很大的数组
int N, num[16777216];

int solve(int left, int right)
{
    //序列长度为1时
    if(left == right)
        return num[left];
    
    //划分为两个规模更小的问题
    int mid = left + right >> 1;
    int lans = solve(left, mid);
    int rans = solve(mid + 1, right);
    
    //横跨分割点的情况
    int sum = 0, lmax = num[mid], rmax = num[mid + 1];
    for(int i = mid; i >= left; i--) {
        sum += num[i];		//子列中元素的个数不确定，只能通过和来隐含判断循环结束
        if(sum > lmax) lmax = sum;
    }
    sum = 0;
    for(int i = mid + 1; i <= right; i++) {
        sum += num[i];
        if(sum > rmax) rmax = sum;
    }

    //答案是三种情况的最大值
    int ans = lmax + rmax;
    if(lans > ans) ans = lans;
    if(rans > ans) ans = rans;

    return ans;
}

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

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

    return 0;
}

5. 动态规划算法（找到一个合适的递推公式，根据上文应该可以有了一个大概的思路）
   用dp[n]=max(0,dp[n-1])+num[n],dp[n]表示以第n个数结尾的最大连续子序列的和

#include <stdio.h>

//N是数组长度，num是待计算的数组，放在全局区是因为可以开很大的数组
int N, num[134217728];

int main()
{
    //输入数据
    scanf("%d", &N);
    for(int i = 1; i <= N; i++)
        scanf("%d", &num[i]);
    
    num[0] = 0;
    int ans = num[1];
    for(int i = 1; i <= N; i++) {
        if(num[i - 1] > 0) num[i] += num[i - 1];
        else num[i] += 0;		//这个地方处理有意思，既不用新建数组，同时使一个新的子列的起点
        if(num[i] > ans) ans = num[i];
    }

    printf("%d\n", ans);

    return 0;
}

1. 最后这一个真的是太秀了(如果没有前面的铺垫，看这个估计是一脸懵的吧)

#include <stdio.h>

int main()
{
    int N, n, s, ans, m = 0;

    scanf("%d%d", &N, &n); //读取数组长度和序列中的第一个数
    ans = s = n; //把ans初始化为序列中的的第一个数
    for(int i = 1; i < N; i++) {
        if(s < m) m = s;
        scanf("%d", &n);
        s += n;
        if(s - m > ans)
            ans = s - m;		//m就相当于那个sum[m-1],s就相当于那个sum[n]
    }
    printf("%d\n", ans);

    return 0;
}