求数组中的最大子数组之和，最长递增子序列

(1)    求数组中的子数组之和的最大值

(2)    求数组中的最长递增子序列

(1)    求数组中的子数组之和的最大值。

题目：输入一个整形数组，数组里有整数也有负数。数组中一个或连续的多个整数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为O(n)。

我们定义nSum表示临时子数组之和，nAll表示子数组之和的最大值。

当nSum < 0 时，则nSum + array[i] < array[i]，故需要放弃前面的子数组，从array[i]重新开始计算子数组之和。

nSum = max(nSum + array[i],array[i])     

每次更新nSum之后，我们需要使用nSum与nAll进行比较，使得nAll保留着nSum的最大值。

nAll = max(nSum, nAll)

实现代码如下：

#include <iostream>
using namespace std;

bool gInvalidInput = false;

int max(int a, int b)
{
	return a > b ? a : b;
}

int FindGreatestSumOfSubArray(int *pData, int nLength)
{
	gInvalidInput = false;
	if (pData == NULL || nLength <= 0)
	{
		gInvalidInput = true;
		return 0;
	}

	int nSum = pData[0];
	int nAll = nSum;
	for (int i = 1; i < nLength; i++)
	{
		nSum = max(nSum + pData[i], pData[i]);
		nAll = max(nAll, nSum);
	}

	return nAll;
}

 void Test(const char *testName, int *pData, int nLength, int maxSum, bool expectedErrorFlag)
 {
	 cout << testName << " : ";
	 if (FindGreatestSumOfSubArray(pData, nLength) == maxSum && gInvalidInput == expectedErrorFlag)
	 {
		 cout << "Passed." << endl;
	 }
	 else
	 {
		 cout << "Failed." << endl;
	 }
 }

 int main()
 {
	 int data1[] = {1, -2, 3, 10, -4, 7, 2, -5};
	 Test("Test1", data1, sizeof(data1) / sizeof(int), 18, false);

	 int data2[] = {-2, -8, -1, -5, -9};
	 Test("Test2", data2, sizeof(data2) / sizeof(int), -1, false);

	 int data3[] = {2, 8, 1, 5, 9};
	 Test("Test3", data3, sizeof(data3) / sizeof(int), 25, false);

	  Test("Test4", NULL, 0, 0, true);
 }

(2)  求数组中的最长递增子序列

题目：输入一个整形数组，求这个数组中最长递增子序列的长度。

假设数组为1, -1, 2, -3, 4, -5, 6, -7。我们定义LIS[N]数组，其中LIS[i]用来表示以array[i]为最后一个元素的最长递增子序列。

使用i来表示当前遍历的位置：

当i = 0 时，显然，最长的递增序列为（1），则序列长度为1。则LIS[0] = 1

当i = 1 时，由于-1 < 1，因此，必须丢弃第一个值，然后重新建立序列。当前的递增子序列为（-1），长度为1。则LIS[1] = 1

当i = 2 时，由于2 > 1，2 > -1。因此，最长的递增子序列为(1, 2)，(-1, 2)，长度为2。则LIS[2] = 2。

当i = 3 时，由于-3 < 1, -1, 2。因此，必须丢掉前面的元素，重建建立序列。当前的递增子序列为（-3），长度为1。则LIS[3] = 1。

依次类推之后，可以得出如下结论。

LIS[i] = max{1, LIS[k] + 1}, array[i] >array[k], for any k < i

最后，我们取max{Lis[i]}。

实现代码如下：

#include <iostream>
using namespace std;

int GetLongestIncSequence(int *pData, int nLength)
{
	if (pData == NULL || nLength <= 0)
	{
		return 0;
	}

	int *LIS = new int[nLength];

	for (int i = 0; i < nLength; i++)
	{
		LIS[i] = 1;
		for (int j = 0; j < i; j++)
		{
			if (pData[i] > pData[j] && LIS[j] + 1 > LIS[i])
			{
				LIS[i] = LIS[j] + 1;
			}
		}
	}

	int longestIncSequence = LIS[0];
	for (int i = 1; i < nLength; i++)
	{
		if (LIS[i] > longestIncSequence)
		{
			longestIncSequence = LIS[i];
		}
	}

	delete []LIS;
	LIS = NULL;

	return longestIncSequence;
}

void Test(const char *testName, int *pData, int nLength, int longestIncSequence)
{
	cout << testName << " : ";
	if (GetLongestIncSequence(pData, nLength) == longestIncSequence)
	{
		cout << "Passed." << endl;
	}
	else
	{
		cout << "Failed." << endl;
	}
}

int main()
{
	int data1[] = {1, 2, 3, 4, 5, 6, 7};
	Test("Test1", data1, sizeof(data1) / sizeof(int), 7);

	int data2[] = {7, 6, 5, 4, 3, 2, 1};
	Test("Test2", data2, sizeof(data2) / sizeof(int), 1);

	int data3[] = {1, -1, 2, -3, 4, -5, 6, -7};
	Test("Test3", data3, sizeof(data3) / sizeof(int), 4);

	int data4[] = {5};
	Test("Test4", data4, sizeof(data4) / sizeof(int), 1);

	Test("Test5", NULL, 0, 0);
}