POJ2533 Longest Ordered Subsequence【最长上升子序列+DP】

Longest Ordered Subsequence

A numeric sequence of ai is ordered if a1 < a2 < ... < aN. Let the subsequence of the given numeric sequence (a1, a2, ..., aN) be any sequence (ai1, ai2, ..., aiK), where 1 <= i1 < i2 < ... < iK <= N. For example, the sequence (1, 7, 3, 5, 9, 4,
8) has ordered subsequences, e.g., (1, 7), (3, 4, 8) and many others. All longest ordered subsequences of this sequence are of length 4, e.g., (1, 3, 5, 8).

Your program, when given the numeric sequence, must find the length of its longest ordered subsequence.

Input

The first line of input contains the length of sequence N (1 <= N <= 1000). The second line contains the elements of sequence - N integers in the range from 0 to 10000 each, separated by spaces.

Output

Output must contain a single integer - the length of the longest ordered subsequence of the given sequence.

This problem contains multiple test cases!

The first line of a multiple input is an integer N, then a blank line followed by N input blocks. Each input block is in the format indicated in the problem description. There is a blank line between input blocks.

The output format consists of N output blocks. There is a blank line between output blocks.



Sample Input

1

7

1 7 3 5 9 4 8

Sample Output

4

[b]问题链接：POJ2533
Longest Ordered Subsequence。[/b]

问题简述：参见上述问题描述。

问题分析：

  这是一个最长上升子序列问题，使用DP算法实现。

  定义dp[i]=以a[i]为末尾的最长上升子序列的长度。

  那么，以a[i]为末尾的最长上升子序列有以下两种情形：

  1.只包含a[i]的子序列

  2.满足j<i并且a[j]<a[i]的以a[j]为结尾的上升子序列末尾，追加上a[i]后得到的子序列

  得：dp[i]=max{1,dp[j]+1|j<i且a[j]<a[i]}

  该算法的时间复杂度为O(n*n)

程序说明：

  除了给出上述算法的程序之外，另外给出一个时间复杂度为O(nlogn)的程序，是用二分查找实现的。

题记：（略）

AC的C++语言程序如下：

/* POJ2533 Longest Ordered Subsequence */

#include <iostream>

using namespace std;

const int N = 1000;
int a
, dp
;

int lis(int n)
{
int res = 0;

for(int i=0; i<n; i++) {
dp[i] = 1;
for(int j=0; j<i; j++)
if(a[j] < a[i])
dp[i] = max(dp[i], dp[j] + 1);
res = max(res, dp[i]);
}
return res;
}

int main()
{
int n;
while(cin >> n) {
for(int i=0; i<n; i++)
cin >> a[i];

cout << lis(n) << endl;
}

return 0;
}

AC的C++语言程序（时间复杂度为O(nlogn)）如下：

/* POJ2533 Longest Ordered Subsequence */

#include <iostream>

using namespace std;

const int N = 1000;
int stack[N+1], ps;

int main()
{
int n, val;
while(cin >> n) {
stack[ps = 0] = -1;

for(int i=1; i<=n; i++) {
cin >> val;

if(val > stack[ps])
stack[++ps] = val;
else {
int left = 1, right = ps, mid;
while(left <= right) {
mid = (left + right) / 2;
if(val > stack[mid])
left = mid + 1;
else
right = mid - 1;
}
stack[left] = val;
}
}

cout << ps << endl;
}

return 0;
}