最长递增子序列

//方法一：直接动态规划
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,dp[1000];
while(cin>>n)
{
vector<int> v(n);
memset(dp,0,sizeof(dp));
for(int i=0; i<n; i++)
cin>>v[i];
for(int i=0; i<n; i++)
for(int j=0; j<i; j++)
if(v[i]>v[j])
dp[i]=max(dp[i],dp[j]+1);
int Max=0;
for(int i=0; i<n; i++)
if(Max<dp[i])Max=dp[i];
cout<<Max+1<<endl;
}
return 0;
}
/*注意！！！方法二测试只通过90%，原因是所求递增序列中可能存在相等的数，而题目中要求不能相同
这个跟最长回文子序列有点像：
(1)最长回文子序列：求原序列与逆序列最长公共子序列
(2)最长递增子序列（含相同元素）：求原序列与排序序列最长公共子序列
*/
//方法二：转化为最长公共子序列问题,
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,dp[1000][1000];
while(cin>>n)
{
vector<int> v(n);
memset(dp,0,sizeof(dp));
for(int i=0; i<n; i++)
cin>>v[i];
vector<int> v1(v);
sort(v1.begin(),v1.end());
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
if(v[i]==v1[j])
dp[i+1][j+1]=dp[i][j]+1;
else dp[i+1][j+1]=max(dp[i][j+1],dp[i+1][j]);
cout<<dp

<<endl;
}
return 0;
}
/*
unsigned int LISS(const int array[], size_t length, int result[])
{
unsigned int i, j, k, max;

//变长数组参数，C99新特性，用于记录当前各元素作为最大元素的最长递增序列长度
unsigned int liss[length];

//前驱元素数组，记录当前以该元素作为最大元素的递增序列中该元素的前驱节点，用于打印序列用
unsigned int pre[length];

for(i = 0; i < length; ++i)
{
liss[i] = 1;
pre[i] = i;
}

for(i = 1, max = 1, k = 0; i < length; ++i)
{
//找到以array[i]为最末元素的最长递增子序列
for(j = 0; j < i; ++j)
{
//如果要求非递减子序列只需将array[j] < array[i]改成<=，
//如果要求递减子序列只需改为>
if(array[j] < array[i] && liss[j] + 1> liss[i])
{
liss[i] = liss[j] + 1;
pre[i] = j;

//得到当前最长递增子序列的长度，以及该子序列的最末元素的位置
if(max < liss[i])
{
max = liss[i];
k = i;
}
}
}
}

//输出序列
i = max - 1;

while(pre[k] != k)
{
result[i--] = array[k];
k = pre[k];
}

result[i] = array[k];

return max;
}

unsigned int LISSEx(const int array[], size_t length, int result[])
{
unsigned int i, j, k, l, max;

//栈数组参数，C99新特性，这里的liss数组与上一个函数意义不同，liss[i]记录长度为i + 1
//递增子序列中最大值最小的子序列的最后一个元素（最大元素）在array中的位置
unsigned int liss[length];

//前驱元素数组，用于打印序列
unsigned int pre[length];

liss[0] = 0;

for(i = 0; i < length; ++i)
{
pre[i] = i;
}

for(i = 1, max = 1; i < length; ++i)
{
//找到这样的j使得在满足array[liss[j]] > array[i]条件的所有j中，j最小
j = 0, k = max - 1;

while(k - j > 1)
{
l = (j + k) / 2;

if(array[liss[l]] < array[i])
{
j = l;
}
else
{
k = l;
}
}

if(array[liss[j]] < array[i])
{
j = k;
}

//array[liss[0]]的值也比array[i]大的情况
if(j == 0)
{
//此处必须加等号，防止array中存在多个相等的最小值时，将最小值填充到liss[1]位置
if(array[liss[0]] >= array[i])
{
liss[0] = i;
continue;
}
}

//array[liss[max -1]]的值比array[i]小的情况
if(j == max - 1)
{
if(array[liss[j]] < array[i])
{
pre[i] = liss[j];
liss[max++] = i;
continue;
}
}

pre[i] = liss[j - 1];
liss[j] = i;
}

//输出递增子序列
i = max - 1;
k = liss[max - 1];

while(pre[k] != k)
{
result[i--] = array[k];
k = pre[k];
}

result[i] = array[k];

return max;
}

一 问题描述

设序列L = <a1, a2, a3, ..., an>是长度为n的序列，L的一个递增序列描述为：<ai1, ai2,..., aik>, 其中下标序列 <i1, i2, ..., ik>是

递增的， 子序列<ai1, ai2, ...., aik> 也是递增的。此递增序列的长度为 k

二 解法1， 转化为LCS问题

先把序列 L 按照从小到大的顺序排列， 得到另一个序列S，再求L和S的最长公共子序列

三 解法2，动态规划

另 len[i] 表示以第 i 个元素结尾的最长递增子序列的长度，最后求出 max { len[i] } 即可

实例 <1, 3, 4, 2, 7>

len[1] = 1, 以1结尾的最长递增子序列是<1>, 长度为1

len[2] = 2, 以3结尾的最长递增子序列是<1,3>, 长度为2

len[3] = 3, 以4结尾的最长递增子序列是<1, 3, 4>, 长度为3

len[4] = 2, 以2结尾的最长递增子序列是<1, 2>，长度为2

那么，如何求len[5]呢？转化为下面的子问题：

第5个元素等于7，找到一个序号在a[5]前面且小于a[5]的元素a[i]， 以a[i]结尾的最长递增子序列加上a[5]， 组成一个新的最长递增子序列，其

长度比原来的多1。比a[5]小的元素有多个（最多4个），那么得到的递增子序列也有多个，其中最长的那个就等于以a[5]结尾的最长递增子序列。

例中，a[3 ]比a[5]小，而且以a[3]结尾的最长递增子序列是最长的， 故以a[5]结尾的递增子序列长度在其基础上加1，等于4

len[5] = 4, 以5结尾的最长递增子序列是<1,3,4,5>，长度为4

四 解法3，对解法2的改进

解法2中，求len[i]的时候， 要从a[1], ... a[i-1]中找出所有比 a[i] 小的元素，而a[1], ... a[i-1]是无序的。查找速度比较慢。

引出数组 f[k] 表示长度等于k的递增子序列中最末尾的元素, 长度越长的序列，其末尾元素也越大，所以f[k]是递增的。

实例 <1, 3, 4, 2, 7>

len[1] = 1, f[1] = a[1] = 1

len[2] = 2, f[2] = a[2] = 3

len[3] = 3, f[3] = a[3] = 4

len[4] = 2, f[2] = a[4] = 2 ( 更新了f[2] )

那么，如何求len[5] 呢？

f[1] = 1, f[2] = 2, f[3] = 4, a[5] = 7，

找出末尾元素比a[5]小，而且长度最长的递增子序列，此例中，

f[3] = 4 表示长度等于3的子序列，其末尾元素为4，这个子序列的长度最长。

a[5]加上此序列形成的新序列长度为4, 然后更新f[4] = a[5] = 7，表示长度

等于4的子序列，其末尾元素等于7

在上面的步骤中，找出末尾元素比a[i]小，而且长度最长的子序列，其实就是

对于f[1], ...f[k]， 从后往前找，第一个比a[i]小的元素就是长度最长的子序列。查找的时候

可以用二分查找方法。故比解法1更快。

*/