PTA 数据结构题目（1）：最大子列和问题（分而治之、在线处理算法）

题目来源：

http://www.icourse163.org/learn/ZJU-93001?tid=1002019005#/learn/content?type=detail&id=1002635003&cid=1002891019&replay=true

问题描述：

问题分析：

对于一般的问题，原始解 都能通过一种 蛮力算法，即穷举法的思想得到。这题也不例外。

如果我们，把输入的数组，所有的子列都历遍，并从中找出最大，即可得出我们的算法。也就是版本一。

学习要点：

1、如何寻找代码中的可改进点

2、通过改进代码，得到更有效的算法

3、了解 在线处理 和分而治之思想

int MaxSubSequm1(int A[], int N)
{
int ThisSum, MaxSum = 0;
int i, j, k;
for (i = 0; i < N; i++)  {  // i 是子列左端的位置
for (j = i; j < N; j++){ //j 是子列右端的位置
ThisSum = 0;               //*
for (k = i; k <= j; k++)   //*
ThisSum += A[k];       //*
if (ThisSum>MaxSum)  // 如果刚得到的子列和更大
MaxSum = ThisSum; // 更新结果

}

}// 循环结束
return MaxSum;
}

然而,

T(N)= O(N^3）    不能让人接受！

思考改进点

1、从历遍的方法？ 是不是一定要用 3 个 for ? 每个for 的作用是什么？

2、能不能 通过 动态规划，增加记录的思想，来减少循环？

3、问题的本质是什么？

3、可不可以考虑另外一种解法？

改进点一： 通过改变记录方式，减少一个for 循环

标记有×× 的是可改进的代码

int MaxSubSequm1(int A[], int N)
{
int ThisSum, MaxSum = 0;
int i, j, k;
for (i = 0; i < N; i++)  {  // i 是子列左端的位置
for (j = i; j < N; j++){ //j 是子列右端的位置
ThisSum +=A[j];               //*
// 对于相同i ,的不同j ,只要在j-1次循环的基础上累加1 项即可

if (ThisSum>MaxSum)  // 如果刚得到的子列和更大
MaxSum = ThisSum; // 更新结果

}

}// 循环结束
return MaxSum;
}

算法复杂度 是吓人的 N^2

在线处理思想

改进点二： 深入问题的本质：极端化

其实，我们注意到，

1、如果全部序列都为正数，即最大子列和就是其自身

2、如果最大子列全部为负数，那么最大子列和就是最小的负数

3、根据1,2 我们有，只有当前子列为正数时，才能使最大子列和增大。

于是，我们可以通过抛弃负子列，保证最大子列和递增。当扫描一遍，最大子列和不再递增时，当前的最大子列和即为我们的解。

在线处理

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

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

}

#另一种思想：分而治之

int Max3( int A, int B, int C )
{ /* 返回3个整数中的最大值 */
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 );
}

例如：

复杂度为？

总结：