最大子列和问题

【题目描述】

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

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

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

【输入格式】

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

【输出格式】

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

【输入样例】

6
-2 11 -4 13 -5 -2

【输出样例】

20

思路1 ：暴力求解，把所有的连续子列和全部都算出来，然后找出最大的那一个；代码如下：

#include<iostream>
using namespace std;
int a[100100];
int main(){
	int n, m=0;
	cin >> n;
	for(int i = 0; i < n; i++){
		cin >> a[i];
	}
	for(int i = 0; i < n; i++){
		for(int j = i; j <= n; j++){
			int sum = 0;
			for(int k = i; k <= j; k++){
				sum += a[k];
			}
			m = max(sum, m);
		}
	}
	if(m < 0)	cout << 0;
	else	cout << m;
	return 0;
}

很显然，这个算法的复杂度为 O(n^3)，肯定会超时，那么，该如何降低复杂度呢 ？

思路2： 已经知道当前从 i 到 j 的和，要计算下一个 j 的时候，就没有必要从头开始往后加；当 j 增加了 1 的时候，其实只要在前面那个 i 到 j 的部分和后面加一个元素就好了，这样，k循环完全可以省略，此时，复杂度降为 O(n^2)；

#include<iostream>
using namespace std;
int a[100100];
int main(){
	int n, m=0;
	cin >> n;
	for(int i = 0; i < n; i++){
		cin >> a[i];
	}
	for(int i = 0; i < n; i++){
		int sum = 0;
		for(int j = i; j <= n; j++){
			sum += a[j];
			m = max(sum, m);
		}
	}
	if(m < 0)	cout << 0;
	else	cout << m;
	return 0;
}

复杂度为O(n^2)，其实也非常大，那么还可以优化吗？ 

思路3：分而治之：大概思路就是把一个比较大的复杂的问题切分成小的块，然后分头去解决它们，最后再把结果合并起来，这就是“分而治之”。

首先假设我们的问题是放在一个数组里面的，这个算法第一步是先“分”，也就是把这个数组从中间一分为二，然后递归地去解决左右两边的问题，递归地去解决左边的问题，得到左边的一个最大子列和，递归地去解决右边的问题，得到右边的一个最大子列和，这两个之中的任何一个不一定是结果，还有一种情况就是跨越边界的最大子列和，找到这三个结果，最后的结果一定是这三个数中间最大的那一个。

int findMax(int a, int b, int c){
	return max(a, max(b, c));
}
int DivideCon(int a[], int left, int right){
	int MaxleftSum, MaxrightSum, MaxmidSum, center;
	if(left == right){
		if(a[left] > 0)	 return a[left]; // 递归终止标志，左边只有一个数
		else	return 0;		// 负数则返回0
	}
	center = (left+right) / 2;
	MaxleftSum = DivideCon(a, left, center); // 左边最大值 
	MaxrightSum = DivideCon(a, center+1, right); // 右边最大值 
	// 跨越中点的最大值
	int Maxmidleft=0, Maxmid1=0;
	for(int i = center; i >= 0; i--){
		Maxmidleft += a[i];
		if(Maxmidleft > Maxmid1){
			Maxmid1 = Maxmidleft;
		}
	}
	int Maxmidright=0, Maxmid2=0;
	for(int i = center+1; i <= right; i++){
		Maxmidright += a[i];
		if(Maxmidright > Maxmid2){
			Maxmid2 = Maxmidright;
		}
	}
	return findMax(MaxleftSum, MaxrightSum, Maxmid1+Maxmid2);
}
int Divide(int a[],int len){
    return DivideCon(a,0,len);
}

思路4：在线处理 

 算法复杂度为 O(n)，是我们可能得到的一个最快的算法；但它是有副作用的，那就是它的正确性不是特别的明显，理解困难

在线：指每输入一个数据就进行即时处理 ，在任何一个地方终止输入，算法都能正确的给出当前的解。

int MaxSubseqSum4(int a[], int n){
	int Max=0, timeMax=0;
	for(int i = 0; i < n; i++){
		timeMax += a[i];  /*向右累加*/
		if(timeMax > Max)	
			Max = timeMax; 		/*发现更大和则更新当前结果*/ 
		else if(timeMax < 0)  /*如果当前子列和为负*/ 
			timeMax = 0;	/*则不可能使后面的部分和增大，抛弃*/ 
	}
	return Max;
}