最大子序列和|算法分析

题目要求：给定一个数序列，计算出其子序列和的最大值

输入样例：4 -3 5 -2 -1 2 6 -2
输出样例：11

一、穷举法

我们最容易想到的是穷举法，就是将所有可能的情况列举出来然后比较得到最大的那个，如下：

int MaxSubsequenceSum(int a[] , int n)
{
	int thisSum, maxSum, i, j, k;
	maxSum = 0;
	for(i=0; i < n; i++)
	{
		for(j=i; j < n; j++)
		{
			thisSum = 0;
			for(k=i; k <= j; k++)
				thisSum += a[k];
			if(thisSum > maxSum)
				maxSum = thisSum;
		}
	}
	return maxSum;
}

这个是最容易想的一种算法，但是其时间复杂度是O(n^3)，主要在于我们在穷举的时候，在那些不是最大子序列和的项上浪费的时间太多了，所以就导致了时间复杂度达到了(n^3)的级别，那么我们接下来就要想方法把那些项去掉

二、升级版穷举法

观察上面代码，我们发现最内层循环求和我们可以在列举时顺带求解，就不用每次求从 j 到 i 的各项和了，而是从 i 开始，逐次加上后一项，一直到数组的最后一项，如果在过程中加了一项之后和是最大的我们就保存下来，这样同样可以达到上面算法的目的

int MaxSubsequenceSum(int a[] , int n)
{
	int thisSum, maxSum, i, j;
	maxSum = 0;
	for(i=0; i < n; i++)
	{
		thisSum = 0;
		for(j=i; j < n; j++)
		{
			thisSum += a[j];
			if(thisSum > maxSum)
				maxSum = thisSum;
		}
	}
	return maxSum;
}

该算法时间复杂度是O(n^2)，它将上一个算法每一步都从头开始算改成了从当前位置往后算，由此将时间复杂度降了一阶，然而当数组变得庞大，(n^2)的复杂度依旧很可怕，我们继续寻找更加快速的算法

三、分治算法

分治算法在求解大规模的问题时经常是很好用的一种算法，其想法是把问题分成若干个规模更小的同类问题，然后递归地求解，最后将求得的结果合在一起即可得到整个问题的解，在这里同样我们可以将这个数组分成左右两个规模更小的数组

int maxSubSum(int a[], int left, int right)
{
	int maxLeftSum, maxRightSum;
	int maxLeftBorderSum, maxRightBorderSum;
	int leftBorderSum, rightBorderSum;
	int center, i;
	if(left == right)				//中间位置
		if(a[left] > 0)
			return a[left];
		else 
			return 0;

	center = (left + right) / 2;
	maxLeftSum = maxSubSum(a, left, center);         //递归分治
	maxRightSum = maxSubSum(a, center+1, right);	 //递归分治
	
	maxLeftBorderSum = 0;
	leftBorderSum = 0;
	for(i = center; i >= left; i--)
	{
		leftBorderSum += a[i];
		if(leftBorderSum > maxLeftBorderSum)
		 	maxLeftBorderSum = leftBorderSum;
	}

	maxRightBorderSum = 0;
	rightBorderSum = 0;
	for(i = center+1; i <= right; i--)
	{
		rightBorderSum += a[i];
		if(rightBorderSum > maxRightBorderSum)
		 	maxRightBorderSum = rightBorderSum;
	}
	return max3(maxLeftSum , maxRightSum, maxLeftSum + maxRightSum);
}

int maxSubsequenceSum(int a[],int n)
{
	return maxSubSum(a, 0, n-1);
}

这个算法虽然看起来复杂，但其时间复杂度却是O(n · log n)的，主要是因为它不再是盲目的穷举，而是有目的性地划分求解，最后得到所有解当中的最大值，max3函数是返回最大值，在这里没有实现该函数。

四、巧妙算法

对于不同的题目偶尔可以找到只适用于该题目的特殊且巧妙的算法，有一点投机取巧的意思，对于这道题，由于求的是最大子序列和，所以我们可以在求解过程中只保留一个最大的，然后用“打擂法”将当前算出来的最大的那个保留到最后

int MaxSubsequenceSum(int a[] , int n)
{
	int thisSum, maxSum, i;
	thisSum = 0;
	maxSum = 0;
	for(i=0; i < n; i++)
	{
		thisSum += a[i];
		if(thisSum > maxSum)
			maxSum = thisSum;
		else if(thisSum < 0)         
		/*巧妙所在：当加上当前值后和小于0时，说明后面的项加上前面这一段都会使和小于
		从后面的项开始求得的和，所以就直接舍弃前面的项*/
			thisSum = 0;    
	}
	return maxSum;
}

该算法时间复杂度是O(n)，是这四种算法中最佳的算法