7-1 最大子列和问题

7-1 最大子列和问题

给定K个整数组成的序列{ N 1 , N 2 , …, N K }，“连续子列”被定义为{ N i , N i+1 , …,Nj}，其中 1≤i≤j≤K。“最大子列和”则被定义为所有连续子列元素的和中最大者。例如给定序列{ -2, 11, -4, 13, -5, -2 }，其连续子列{ 11, -4, 13 }有最大的和20。现要求你编写程序，计算给定整数序列的最大子列和。

本题旨在测试各种不同的算法在各种数据情况下的表现。各组测试数据特点如下：

• 数据1：与样例等价，测试基本正确性；
• 数据2：10^2个随机整数；
• 数据3：10^3个随机整数；
• 数据4：10^4个随机整数；
• 数据5：10^5个随机整数；

输入格式:

输入第1行给出正整数K (≤100000)；第2行给出K个整数，其间以空格分隔。

输出格式:

在一行中输出最大子列和。如果序列中所有整数皆为负数，则输出0。

输入样例:

6
-2 11 -4 13 -5 -2

输出样例:

20

代码长度限制

16 KB 时间限制 10000 ms 内存限制 64 MB 栈限制 8192 KB

#include <iostream>
using namespace std;
// 课本17页，由题最大系列和，为负数是输出0

// 方法一，直接三个循环
// 超时
int MaxSubseqSum1(int List[], int N) {
    // N个数，列表序为0~N-1
    int ThisSum = 0, MaxSum = 0;  // ThisSum是当前子列和，MaxSum是返回值
    for(int i=0; i<N; i++) {
        for(int j=i; j<N; j++) {
            ThisSum = 0;  // 当前最大子列和归零
            for(int k=i; k<=j; k++) {
                ThisSum += List[k];  // 当前最大子列和增加
            }
            if(ThisSum > MaxSum) {  // 如果刚刚得到的这个子列和更大
                MaxSum = ThisSum;  // 更新最大子列和
            }
        }
    }

    return MaxSum;
}

void fun1() {
    // 读取列表
    int K;
    cin >> K;
    int a[K];
    for(int i=0; i < K; i++) {
        cin >> a[i];
    }
    cout << MaxSubseqSum1(a, K);
}


// 方法二：方法一的改进，注意到对于固定的i，当计算到第j个时，当前最大子列和完全可以由前一个子列和加上第j个
// 3279 / 10000 ms
int MaxSubseqSum2(int List[], int N) {
    //
    // N个数，列表序为0~N-1
    int ThisSum = 0, MaxSum = 0;  // ThisSum是List[i]到List[j]的子列和，MaxSum是返回值
    for(int i=0; i<N; i++) {
        ThisSum = 0;  // 当前最大子列和归零
        for(int j=i; j<N; j++) {
            ThisSum += List[j];  // 当前最大子列和增加
            if(ThisSum > MaxSum) {  // 如果刚刚得到的这个子列和更大
                MaxSum = ThisSum;  // 更新最大子列和
            }
        }
    }

    return MaxSum;
}

void fun2() {
    // 读取列表
    int K;
    cin >> K;
    int a[K];
    for(int i=0; i < K; i++) {
        cin >> a[i];
    }
    cout << MaxSubseqSum2(a, K);
}


// 方法三：分冶法，分而治之，用递归
// 20 / 10000 ms
/* 第一步：将序列中分成左右两个子系列
 * 第二步：递归求两子列的最大和S左 S右
 * 第三步：从中分点分头向左右两边扫描，找出跨过分界线的最大系列和S
 * 第四步：Smax = max（S左，S中，S右）
 * 只有这样才能包含所有情况，自己想
 * 难理解的就是包含中分点的子列和，其左子列和最大，右子列和最大，则它子列和最大，因为都从中心出发，找到最大，则整体最大
 */
int Max3(int A, int B, int C) {
    return A>B ? (A>C ? A:C):(B>C ? B:C);
}

int DividAndConquer(int List[], int left, int right) {
    // 分冶法求List[left]到left[right]的最大子列和

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

    // 先看左右
    int center = (left + right)/2;  // 是向下取整的
    int MaxLeftSum = DividAndConquer(List, left, center);  // 递归找到左边最大子列和
    int MaxRightSum = DividAndConquer(List, center+1, right);  // 递归找到右边最大子列和

    // 再看跨分界线的


    int MaxLeftBorderSum=0, MaxRightBorderSum=0;  // 存放跨分界线的结果

    // 中间向左扫描
    int LeftBorderSum=0;
    for(int i=center; i>=left; i--) {
        LeftBorderSum += List[i];
        if(LeftBorderSum > MaxLeftBorderSum)
            MaxLeftBorderSum = LeftBorderSum;
    }

    // 中间向右扫面
    int RightBorderSum=0;
    for(int 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) {
    return DividAndConquer(List, 0, N-1);
}

void fun3() {
    // 读取列表
    int K;
    cin >> K;
    int a[K];
    for(int i=0; i < K; i++) {
        cin >> a[i];
    }
    cout << MaxSubseqSum3(a, K);
}


// 方法四：在线处理，每输入一个就及时处理
/* 17 / 10000 ms
 * 核心思想：如果有一段最大子列和是从i到j的求和，则必定有从i到l（i<=l<=j）的求和大于等于0（由题）
 * 所以一旦发现当前子列和为负，则可以重新考察一个新的子列
 */
int MaxSubseqSum4(int N) {
    int ThisSum = 0, MaxSum = 0;  // 定义当前子列和跟最大子列和为0
    for(int i=0; i<N; i++) {
        int num;
        cin >> num;
        ThisSum += num;  // 向右累加
        if(ThisSum > MaxSum)
            MaxSum = ThisSum;
        else if(ThisSum < 0)
            ThisSum = 0;  // 舍弃当前子列和
    }
    return MaxSum;
}

void fun4() {
    int K;
    cin >> K;
    cout << MaxSubseqSum4(K);
}

int main(int argc, char *argv[]) {
    fun4();
}