解决最大子列和问题的6种算法
【时间】2018.12.07
【题目】解决最大子列和问题的5种算法
概述
本文的主要内容来自于对中国慕课MOOC中浙大《数据结构》课程中的1.3节的整理。最大子列和问题是给定一个N长度的序列，求出它的最大子列和。本文中用于验证的主函数为：
#include
#define MAXN 100000
int main(void) {
int K, i;
int a[MAXN] = {0};
scanf_s("%d", &K);
for ( i = 0; i < K; i++ )
scanf_s("%d", &a[i]);
printf("%d", MaxSubseqSum1( a, K )); //不同方法此处修改函数名即可。
return 0;
}
一、方法一：暴力破解------O（N^3)
暴力破解使用穷举法。简单来说，我们只要用两层循环枚举起点和终点，这样就尝试了所有的子序列，然后在用一层循环计算每个子序列的和，然后找到其中最大的即可。
int MaxSubseqSum1 ( 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; // 每轮都要把ThisSum归零，累加新一轮的子列和。
for ( k = i; k < j; k++ ) //将A[i]~A[j]累加，得到子列和。
ThisSum += A[k];
if ( ThisSum > MaxSum ) //如果这轮的子列和比最大子列和还大，存入MaxSum.
MaxSum = ThisSum;
}
}
return MaxSum;
}【运行结果】
二、方法二：二重循环----O（N^2)
改进点：对于相同的子列左端位置 i ，不同的右端位置 j ，我们只要每次在右端累加一项，即可求得每一个子列和。 这样就可以减少一层循环。
int MaxSubseqSum2 ( int A[], int N ) {
int ThisSum, MaxSum = 0;
int i, j;
for ( i = 0; i < N; i++ ) { //i是子列左端位置。
ThisSum = 0; //A[i]~A[j]的子列和。
for ( j = i; j < N; j++ ) { //j是子列右端位置。
ThisSum += A[j]; //对于相同的i，不同的j，只要在j-1处再累加1项即可。
if ( ThisSum > MaxSum ) //更新MaxSum.
MaxSum = ThisSum;
}
}
return MaxSum;
}
三、使用分治算法-----O（NlogN)
基本思路：
- 将序列从中间分为左右两个子序列。
- 递归求得两个子列的最大和。
- 从中分点分头向左、右两边扫描，找出跨过分界线的最大子列和。
- 输出这三个子列和最大的一个。
【注意】递归终止的条件是子序列的左端==右端，即子序列只有一个数的时候。
【代码】：
/*返回三个整数的最大值*/
int Max3 ( int A, int B, int C ) {
return (A > B) ? (A > C ? A : C) : (B > C ? B : C);
}
/*分治法球List[left]到List[right]的最大子列和*/
int DivideAndConquer ( int List[], int left, int right ) {
int MaxLeftSum, MaxRightSum; //存放左右子问题的解。
int MaxLeftBorderSum, MaxRightBorderSum; //存放跨分界线的结果。
int LeftBorderSum, RightBorderSum;
int center, i;
/*递归的终止条件，子列只有1个数字*/
if ( left == right ) {
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 ) {
return DivideAndConquer ( List, 0, N-1 );
}
四、在线处理----O（N）
所谓在线的意思，是指每输入一个数据就进行即时处理，这样，在任何一个地方中止输入，算法都能给出当前的正确解。这里用到了动态规划，很像数学中的递推。 我们用dp[n]表示以第n个数结尾的最大连续子序列的和，于是存在以下递推公式：
dp[n] = max(0, dp[n-1]) + num[n]
【代码1】
int MaxSubseqSum4( int A[], int N ) {
int ThisSum, MaxSum, 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;
}【代码2】递推式的实现
int MaxSubseqSum3(int A[], int N) {
int ThisSum, MaxSum, i;
ThisSum = A[0];
MaxSum = (ThisSum > 0) ? ThisSum : 0;
for (i = 1; i < N; i++) {
if (ThisSum > 0)
ThisSum += A[i];
else
ThisSum = A[i]; //实现递推式dp[n] = max(0, dp[n-1]) + num[n]
if (ThisSum > MaxSum)
MaxSum = ThisSum; /* ·发现更大和则更新当前结果 */
}
return MaxSum;
}五、另一个在线处理算法----O（N）
思路：以第n个数为结尾的最大子序列和有什么特点？假设这个子序列的起点是m，于是结果为sum[n] - sum[m-1]。并且，sum[m-1]必然是sum[1],sum[1]...sum[n]中的最小值！这样，我们如果在计算sum数组的时候，同时保存之前的最小值lmin， 那么只要计算sum[n] -lmin即可得到最大子序列和！
代码：
int MaxSubseqSum5(int A[], int N) {
int ThisSum, MaxSum, i,lmin;
ThisSum = MaxSum = lmin = 0;
for (i = 0; i < N; i++) {
ThisSum += A[i];
if (ThisSum < lmin)
lmin = ThisSum;
if ((ThisSum - lmin) > MaxSum)
MaxSum = ThisSum - lmin;
}
return MaxSum;
}
参考链接：https://blog.csdn.net/YelloJesse/article/details/82312659
https://www.cnblogs.com/conw/p/5896155.html