01-复杂度1 最大子列和问题   (20分)

给定KKK个整数组成的序列{
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个随机整数；<
4000
/span>
数据4：104个随机整数；
数据5：105个随机整数；

输入格式:

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

输出格式:

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

输入样例:

6
-2 11 -4 13 -5 -2

输出样例:

20

思路：

1、三重循环，将所有子序列都遍历过去

2、二重循环，发现1中的第三个循环是多余的，每次把ThisSum置零后，再从第一个开始加，实际上可以直接累加

3、分而治之，先找到左边的最大子列和，再找到右边的最大子列和，再算出跨越边界的最大子列和，最后取三者最大的（不太理解）

4、在线处理，并不需要遍历所有子序列，只要和是负的序列，就抛弃。

#include <stdio.h>
#include <stdlib.h>
#include <time.h> //测试时间所需头文件
clock_t start, stop;
double duration; //函数运行时间表示（单位CLK_TCK=1000，这里不是这个单位，而是这个单位的MAXK倍）
#define CLK_TCK CLOCKS_PER_SEC
#define N 100005
#define MAXK 1e6 //重复执行使duration能够表示时间

int MaxSubseqSum1 ( int a[], int n ) { //最笨的办法，时间复杂度O（N^3）
int ThisSum, MaxSum = 0;
for ( int i = 0; i < n; i++ )
for ( int j = 0; j < n; j++ ) {
ThisSum = 0; //新的序列开始，重置
for ( int k = i; k <= j; k++ ) {
ThisSum += a[k];
if ( ThisSum > MaxSum )
MaxSum = ThisSum;
}
}
return MaxSum;
}

int MaxSubseqSum2 ( int a[], int n ) { //稍微简单点的办法，二重循环，O（N^2）
int ThisSum, MaxSum = 0;
for ( int i = 0; i < n; i++ ) {
ThisSum = 0; //重置？？？
for ( int j = i; j < n; j++ ) { //j=i重点
ThisSum += a[j];
if ( ThisSum > MaxSum )
MaxSum = ThisSum;
}
}
return MaxSum;
}
int Max3 ( int A, int B, int C ) {
//返回3个整数中的最大值
return A > B ? (A > C ? A : C) : (B > C ? B : C);
//先从A和B找出大的数，如果A大，那么再从A和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 ( int 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 a[], int n ) { //分而治之 O（N*logN）
return DivideAndConquer( a, 0, n - 1 );
}

int MaxSubseqSum4 ( int a[], int n ) { //在线处理 O（N）
int ThisSum = 0, MaxSum = 0;
for ( int i = 0; i < n; i++ ) {
ThisSum += a[i];
if ( ThisSum > MaxSum )
MaxSum = ThisSum;
else if ( ThisSum < 0 )
ThisSum = 0; //负数不可能使后面的部分和增大，抛弃
}
return MaxSum;
}

double running_time ( int (*func)( int a[],int n ), int a[], int K ) { //函数中要实用数组a，因此作为形参
start = clock();
for ( int i = 0; i < MAXK; i++ )
(*func)( a, K );
stop = clock();
duration = (double)(stop-start) / CLK_TCK;//本应该再除MAXK，这里为了简便，只为比较大小
return duration;
}

int main()
{
int a
, K;
scanf("%d", &K);
for ( int i = 0; i < K; i++ ) {
scanf("%d", &a[i]);
}
//printf( "MaxSubseqSum1=%d\n",MaxSubseqSum1( a, K ) );
//printf( "the running time of MaxSubseqSum1 is %lf\n\n", running_time( MaxSubseqSum1, a, K ) );//调用函数作为形参时，只需函数名

//printf( "MaxSubseqSum2=%d\n",MaxSubseqSum2( a, K ) );
//printf( "the running time of MaxSubseqSum2 is %lf\n\n", running_time( MaxSubseqSum2, a, K ) );

//printf( "MaxSubseqSum3=%d\n",MaxSubseqSum3( a, K ) );
//printf( "the running time of MaxSubseqSum3 is %lf\n\n", running_time( MaxSubseqSum3, a, K ) );

//printf( "MaxSubseqSum4=%d\n",MaxSubseqSum4( a, K ) );
//printf( "the running time of MaxSubseqSum4 is %lf\n\n", running_time( MaxSubseqSum4, a, K ) );

//printf( "%d", MaxSubseqSum1( a, K ) ); //1w和10w个数据超时
//printf( "%d", MaxSubseqSum2( a, K ) ); //10w个数据花了10s
//printf( "%d", MaxSubseqSum3( a, K ) );
printf( "%d", MaxSubseqSum4( a, K ) );

system("pause");
return 0;
}