《数据结构》——最大子列和问题（多方案）

题目

给定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：个随机整数；
• 数据3：个随机整数；
• 数据4：个随机整数；
• 数据5：个随机整数；

输入格式

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

输出格式

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

输入样例

6

-2  11 -4 13 -5 -2

输出样例

20

---

算法一

思路：暴力美学，使用穷举法，将输入的正整数序列的每种情况就行对比，需要使用三重循环以求出最长子序列之和。

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;   
}

时间复杂度：

思考：

• 能够取消一层循环？
• 能否时间复杂度减低一下？
• 问题的核心是什么？

算法二

思路：暴力操作，使用二重循环，降低时间复杂度。

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

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

		}

	}// 循环结束
	return MaxSum;   
}

时间复杂度:

思考：

• 时间复杂度为能变成？
• 问题中的特殊情况

1. 如果全部序列都为正数，即最大子列和就是其自身
2. 如果最大子列全部为负数，那么最大子列和就是最小的负数
3. 所以，只有当前子列为正数时，才能使最大子列和增大。

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

算法三

思路：分而治之，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。在此问题中，将一个大的序列分为两个小的序列，再进行分解......直到每个小序列只有一个数值，在每个小序列中，需要求出：

1）左边序列最大子列和（时间复杂度为T(n/2))；

2）右边序列最大子列和(时间复杂度为T(n/2))；

3）横跨左右划分边界的最大子列和（左边扫描一遍，右边扫描一遍，每个数值只扫描了一遍，时间复杂度为O(n)）;

求出之后其中最大值就是最大子序列和。

    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 );
    }

 

算法四

思路：在线处理，在线 的意思是指每输入一个数据就进行 即时处理 ，在任何一个地方终止输入，算法都能能正确给出当前解。抛弃结果为负的子列，保证最大子列和递增。

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;

}

时间复杂度

思考：

• 能不能对中间的结果进行保存，使用其他算法，如动态规划，贪心算法？
• 各种算法的核心是什么？

算法五

思路：动态规划，状态转移方程为：MaxSum[i] = Max{ MaxSum[i-1] + A[i], A[i]};对于最大连续子列和来说，往往是有两种情况，一种是一直相加，中间某一过程中最大，另一种是重新开始的子列和最大。MaxSum[i] 表示前i个最大连续子列和。时间复杂度为O(n)

int dp(int A[],int N)
{
	int *dp = new int[N];
	dp[0] = A[0];   //边界
	int MaxSum = dp[0];
	for(int i = 1;i < N;i++)
	{
		dp[i] = (dp[i-1] + A[i] > A[i]) ?(dp[i-1] + A[i]):A[i];
		if(dp[i] > MaxSum)
			MaxSum = dp[i]; 
	}
	
	return MaxSum; 
}