动态规划：最长连续递增子序列

之前我写过一篇
动态规划：最长连续递增子序列的元素个数，
后面有个思考：最长连续递增子序列
大家发现使用多个数组进行保存，然后相互比较比较麻烦。那么能不能有简单的办法呢？
其实是有的，大家还记得前面的最长回文子串吗，我们如果用dp[i][j]代表i—j是否是连续增子序列，具体细节看代码。

#include<iostream>
using namespace std;
#include<algorithm>
#include<vector>
#include<string>
//求最长子序列
class Solution {
public:

	//最长连续字符串 从小大大
	vector<int> longeseries(vector<int> s) {

		
		vector<int> v;
		if (s.size()==0)
		{
			return v;
		}

		vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));

		int start = 0;
		int longth = 1;
		
		for (int j = 1;j < s.size();j++)
		{
			for (int i = 0;i < s.size() - 1 && i < j;i++)
			{
				if ((s[i] >= s[j]))  //比如说 {1,1 }  显然不是递增
				{
					dp[i][j] = 0;	
				}
				else//{1,x,y,8}  但是我们还要比较两端相邻的数，是否符合递增关系
				{
					if (j - i > 2)//  {x,y...m,n}
					{
						if (s[i] <= s[i + 1] && s[j-1] <= s[j])
						{
							dp[i][j] = dp[i + 1][j - 1];//{1,3...6,8}
						}
						else
						{
							dp[i][j] = 0;////{1,3...10,8}
						}
					}
					else if (j - i == 2) //{ 1, x,  8 }
					{
						if (s[i] <= s[i + 1] && s[i + 1] <= s[j])
						{
							dp[i][j] = 1;
						}
						else
						{
							dp[i][j] = 0;
						}
					}
					else if (j - i == 1)// { 1,  8 }
					{
						dp[i][j] = 1;
					}
				}
				//每次只要有满足递增条件的进行判断是否最大序列
				if (dp[i][j] == 1)
				{
					if (j - i + 1 > longth)
					{
						longth = j - i + 1;
						start = i;
					}
				}			
			}
		}
		cout << "longth=" << longth << endl;
		auto  start1 = s.begin()+ start;
		vector<int> result(start1, start1 +longth);
		return  result;
	}
};


//最长子序列
int main()
{
	Solution  su;
	vector<int> v = { 1,2,3,1,8,9,10,11,5,6 };
	//vector<int> v = {3,1,8 ,9};
	vector<int> result;
	result=su.longeseries(v);
	for (auto it= result.begin();it!=result.end();it++)
	{
		cout << *it << " ";
	}

}

这样就可以输出了。基本代码模仿的是最长回文字符床