动态规划解决求数组中最长递增子序列长度，并能够打印出增长的序列

解法一

根据无后效性的定义我们知道，将各阶段按照一定的次序排列好之后，对于某个给定阶段的状态来说，它以前各阶段的状态无法直接影响它未来的决策，而只能间接地通过当前状态来影响。换句话说，每个状态都是过去历史的一个完整总结。

同样地，仍以序列1，-1，2，-3，4，-5，6，-7中为例，我们在找到4之后，并不关心4之前的两个值具体是怎样，因为它对找到6并没有直接影响。因此，这个问题满足无后效性，可以使用动态规划来解决。

可以通过数字的规律来分析目标串：1，-1，2，-3，4，-5，6，-7。

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

当i=1时，显然，最长的递增序列为（1），序列长度为1.

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

当i=3时，由于2>1，2>-1。因此，最长的递增序列为（1,2），（-1,2），长度为2。在这里，2前面是1还是-1对求出后面的递增序列没有直接影响。

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

假设在目标数组array[]的前i个元素中，最长递增子序列的长度为LIS[i]。那么，

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

即如果array[i+1]大于array[k]，那么第i+1个元素可以接在LIS[k]长的子序列后面构成一个更长的子序列。与此同时array[i+1]本身至少可以构成一个长度为1的子序列。

根据上面的分析，可以得到如下的代码：

// DP4.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
using namespace std;

const int N =1024;
int a[N];
int dp[N];

int solve(int a[],int len)
{
int ans=0;
for (int i=0;i<len;i++)
{
for (int j=0;j<i;j++)
{
if (a[i]>a[j] && dp[i]<dp[j]+1)
{
dp[i]=dp[j]+1;

}
}
if (dp[i]>ans)
{
cout<<a[i]<<" ";
ans=dp[i];
}

}
cout<<endl;
return ans;

}

int _tmain(int argc, _TCHAR* argv[])
{
int n=0;
cin>>n;//n代表有多少个数
for (int i=0;i<n;i++)
{
cin>>a[i];
dp[i]=1;
}
int ans=solve(a,n);
cout<<ans<<endl;

system("pause");
return 0;
}

// DP4.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
using namespace std;

const int N =1024;
int a[N];
int dp[N];

int solve(int a[],int len)
{
	int ans=0;
	for (int i=0;i<len;i++)
	{
		for (int j=0;j<i;j++)
		{
			if (a[i]>a[j] && dp[i]<dp[j]+1)
			{
				dp[i]=dp[j]+1;
				
			}
		}
		if (dp[i]>ans)
		{
			cout<<a[i]<<" ";
			ans=dp[i];
		}
	
	}
	cout<<endl;
	return ans;

}


int _tmain(int argc, _TCHAR* argv[])
{
	int n=0;
	cin>>n;//n代表有多少个数
	for (int i=0;i<n;i++)
	{
		cin>>a[i];
		dp[i]=1;
	}
	int ans=solve(a,n);
	cout<<ans<<endl;
	

	system("pause");
	return 0;
}