最长递增子序列

方法一，转为求公共子序列
先对原序列进行排序
然后用对原序列和新序列求其最长公共子序列
所得即原序列的最长非递减子序列
注意，由于所求出来的是最长非递减子序列，所以可能和所要求的不一样，慎用

而且下面所示的代码用的是递归的方法来实现的，时间复杂度和空间复杂度都是O(2^N)，真要实现的时候最好采用动态归化+滚动数组的方法

 

实现代码：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
template<typename InIt>
size_t LCS( InIt _First1, InIt _Last1, InIt _First2, InIt _Last2 )
{
if( _First1 == _Last1 || _First2 == _Last2 )
{
return 0;
}

if( *_First1 == *_First2 )
{
return 1 + LCS( _First1 + 1, _Last1, _First2 + 1, _Last2 );
}
else
{
return max( LCS( _First1, _Last1, _First2 + 1, _Last2 ),
LCS( _First1 + 1, _Last1, _First2, _Last2 ) );
}
}
int main()
{
int n = 0;
vector<int> array;
while( (cin >> n) && ( n != 0 ) ) array.push_back( n );
size_t m = 0;
cin >> m;

vector<int> arraySorted( array.begin(), array.end() );
sort( arraySorted.begin(), arraySorted.end() );

cout << LCS( array.begin(), array.end(), arraySorted.begin(), arraySorted.end() ) << endl;

return 0;
}

 

 

方法二：
方法二就是使用动态归化的方法
设L[i]为以第i个元素结尾的最长递增子序列的长度
最后在所有L[i]中取MAX即为所求 

template< typename T >
int LIS( T* array, int count )
{
if( count == 0 ) return 0;

vector<int> L( count, 1 );

for( int i = 1; i < count; i++ )
{
for( int j = 0; j < i; j++ )
{
if( array[i] > array[j] && L[j] + 1 > L[i] )
{
L[i] = L[j] + 1;
}
}
}

int maxL = 0;
for( int i = 0; i < count; i++ )
{
if( maxL < L[i] ) maxL = L[i];
}
return maxL;
}

 

 

方法三：
方法三和方法二类似，也是使用动态归化的方法
但不同之处是，使用L[i]表示，前i个元素中的最长递增子序列的长度
而且使用labels[i].pos表示，由i个元素组成的最长递增子序列的最后一个元素的位置，而且是所有最后一个元素中最小的一个
这样，其实会导致 i < j的时候 array[ labels[i].pos ] < array [ labels[j].pos ]，即array[labels[i].pos]是一个单调递增函数
所以可以使用二分查找的方法，来找到第一个小于当前元素array[i]的array[ labels[i].pos ]的最大的i的位置

#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm>
using namespace std;
template<typename T>
struct Program
{
static vector<T> array;
static vector<int> parent;

struct Label
{
int pos;

Label(): pos( -1 ) {}
Label( int _pos ): pos( _pos ) {}

bool operator <( const Label& l ) const
{
if( pos == -1 && l.pos == -1 ) return false;
else if( pos == -1 ) return true;
else if( l.pos == -1 ) return false;
else return array[pos] < array[l.pos];
}
};
void LIS( size_t m = 0 )
{
if( array.empty() ) return;

vector<size_t> L( array.size(), 1 );
vector<Label> labels( array.size() + 1 );

labels[1].pos = 0;
size_t maxL = 1;
for( size_t i = 1; i < array.size(); i++ )
{
typename vector<Label>::const_iterator it = lower_bound( labels.begin(), labels.begin() + maxL + 1, Label( i ) );
int j = it - labels.begin() - 1;

L[i] = j + 1;
if( maxL < L[i] )
{
maxL = L[i];
labels[maxL].pos = i;
parent[i] = labels[j].pos;

}
else if( array[i] < array[labels[j + 1].pos] )
{
labels[j + 1].pos = i;
parent[i] = labels[j].pos;
}
}

vector<T> tracks;
int p = labels[maxL].pos;
while( p != -1 )
{
tracks.push_back( array[p] );
p = parent[p];
}

reverse_copy( tracks.begin(), tracks.end(), ostream_iterator<T>( cout, " " ) );
cout << endl;
}
};
template<typename T>
vector<T> Program<T>::array;
template<typename T>
vector<int> Program<T>::parent;
int main()
{
Program<int> p;
int n = 0;
while( (cin >> n) && ( n != 0 ) )
{
p.array.push_back( n );
p.parent.push_back( -1 );
}
p.LIS();
return 0;
}