最大子列和求解及分析

最近在MOOC学习浙大的数据结构课 ，第一章的最大子列和问题描述如下：

给定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行给出正整数K (≤100000)；第2行给出K个整数，其间以空格分隔。

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

输入样例:
6
-2 11 -4 13 -5 -2
输出样例:
20

暴力求解

设置两层循环，第一层遍历整个数组，第二层求每一次的子列和，时间复杂度为O(n²)。

int MaxSubseqSum2(int A[], int N){
	int ThisSum, MaxSum = 0;
	int i, j;
	for(i=0; i<N; i++){
		ThisSum = 0;
		for(j=i; j<N; j++){
			ThisSum += A[j];
			if (ThisSum >= MaxSum) {
				MaxSum = ThisSum;
			}
		}
	}
	return MaxSum;
}

分治法

继续考虑能否提升算法效率，于是采用分治法。我们有一个很复杂的大问题，很难直接解决它，但是我们发现可以把问题划分成子问题，如果子问题规模还是太大，并且它还可以继续划分，那就继续划分下去。直到这些子问题的规模已经很容易解决了，那么就把所有的子问题都解决，最后把所有的子问题合并，我们就得到复杂大问题的答案了。可能说起来简单，但是仍不知道怎么做，接下来分析这个问题，将整个序列从中分为左右两个子序列，最大子列和只有三种情况：

1. 所求序列完全包含在左半部分的序列中。
2. 所求序列完全包含在右半部分的序列中。
3. 所求序列刚好横跨分割点，即左右序列各占一部分。

求左右子列和方法类似，递归不断减小问题规模，直到只剩一个数字，返回自身即可，如果是负数就返回零；跨越中点的序列和怎么求呢？可以从中点向左遍历，直到遍历完整个左边，右边同理，两者相加就是跨越中点的子列和。

int Max3( int A, int B, int C )
{ /* 返回3个整数中的最大值 */
	return A > B ? A > C ? A : C : B > C ? B : C;
	return A > B ? A > C ? A : C : B > C ? B : C;
}

int DivideAndConquer( int List[], int left, int right )
{ /* 分治法求List[left]到List[right]的最大子列和 */
	int MaxLeftSum, MaxRightSum; /* 存放左右子问题的解 */
	int MaxLeftBorderSum, MaxRightBorderSum; /*存放跨分界线的结果*/
 
	int LeftBorderSum, RightBorderSum;
	int center, i;
 
	if( left == right )  { /* 递归的终止条件，子列只有1个数字 */
		if( List[left] > 0 )  return List[left];
		else return 0;
	}
 
	/* 下面是"分"的过程 */
	center = ( left + right ) / 2; /* 找到中分点 */
	/* 递归求得两边子列的最大和 */
	MaxLeftSum = DivideAndConquer( List, left, center );
	MaxRightSum = DivideAndConquer( List, center+1, right );
 
	/* 下面求跨分界线的最大子列和 */
	MaxLeftBorderSum = 0; LeftBorderSum = 0;
	for( i=center; i>=left; i-- ) { /* 从中线向左扫描 */
		LeftBorderSum += List[i];
		if( LeftBorderSum > MaxLeftBorderSum )
			MaxLeftBorderSum = LeftBorderSum;
	} /* 左边扫描结束 */
 
	MaxRightBorderSum = 0; RightBorderSum = 0;
	for( 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 )
{ /* 保持与前2种算法相同的函数接口 */
	return DivideAndConquer( List, 0, N-1 );
}

分治法的递归深度为logn，时间复杂度为O(nlogn)，空间复杂度为O(nlogn)。

在线处理

继续优化算法，在线处理的意义就在于在任一点终止输入都会得到当前的输出值。在线处理的时间复杂度达到了最优O(n)。

int MaxSubseqSum4(int A[], int N){
	int ThisSum, MaxSum, i;
	ThisSum = MaxSum = 0;
	for (i = 0; i < N; i++) {
		ThisSum += A[i];
		if (ThisSum < 0)
			ThisSum = 0;//当前和为负数，表明只会使后面的和越来越小，直接舍去
		else if (ThisSum > MaxSum)
			MaxSum = ThisSum;//更新最大和
	}
	return MaxSum;
}

测试的main函数如下：

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include "MaxSunseqSum2.h"
#include "MaxSubseqSum3.h"
#include "MaxSubseqSum4.h"
#define MAXN 100000//定义数组最大长度

//计算程序运行时间
clock_t start, finish;
double duration;

int main(){
	srand(time(NULL));//生成随机数种子
	int N;
	int A[MAXN] = {0};
	scanf("%d", &N);
	for (int i=0; i<N; i++) {
		A[i] = (rand()%(N+1)-N/2);//随机生成整数给数组赋值
	}
	start = clock();
	for (int i=0; i<N; i++) {
		printf("%d ", A[i]);
	}
	printf("\n最大子列和：%d\n", MaxSubseqSum4(A, N));
	finish = clock();
	duration = (double)(finish-start)/CLOCKS_PER_SEC;
	printf("耗时%lf秒\n", duration);
	return 0;
}