剑指offer-连续子数组的最大和

题目描述

HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)

代码如下

/*
 在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。
 但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？
 例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。
 你会不会被他忽悠住？(子向量的长度至少是1)
 */
int MaxOfArray(const vector<int>& array, int lo, int hi);
int FindGreatestSumOfSubArray(vector<int> array)
	{
	int size = array.size();
	if(size == 0) return 0;
	int max = -256, k = 1;
	for(int i = 0; i < size; i++)
		{
		for(int j = 0; j < size; j++)
			{
			int maxArray = MaxOfArray(array, j, j+k);
			if(max < maxArray)
				max = maxArray;
			}
		k++;           
		}
	return max;
	}
int MaxOfArray(const vector<int>& array, int lo, int hi)
	{
	int sum = 0; 
	for(int i = lo; i < array.size() && i < hi; i++)
		sum += array[i];
	return sum;
	}
//动态规划算法
//动态规划思想。状态方程：
// max( dp[ i ] )  = getMax(  max( dp[ i -1 ] ) + arr[ i ] ,arr[ i ] ) 
// 式子意义：我们从头开始遍历数组，遍历到数组元素 arr[ i ] 时，连续的最大的和
// 可能为 max( dp[ i -1 ] ) + arr[ i ] ，也可能为 arr[ i ] 
// 做比较即可得出哪个更大，取最大值。时间复杂度为 n
int getMax(const int a, const int b)
	{return a > b ? a : b;}
int FindGreatViaDynamic(const vector<int>& vecint)
	{
		int size = vecint.size();
		if(size == 0) return 0;
		int sum = vecint[0];
		int max = vecint[0];
		for(int i = 0; i < size; i++)
			{
				sum = getMax(sum + vecint[i],vecint[i]);
				if(max < sum)
					max = sum;
			}
		return max;
	}
int QuickFindGreatSumOfSub(const vector<int>& vecint)
	{
		int size = vecint.size();
		if(size == 0) return 0;
		int sum = 0, max = 0;
		for(int i = 0; i < size; i++)
			{
			}
	}
int FindGreatesSumOfSubArrayTest()
	{
		int Array[] = {6,-3,-2,7,-15,1,2,2};
		vector<int> vecint;
		for(int i = 0; i < 8; i++)
			vecint.push_back(Array[i]);
		int maxOfSubArray = FindGreatestSumOfSubArray(vecint);
		return 0;
	}