POJ2533(KB12-N LIS)

  

Longest Ordered Subsequence

Time Limit: 2000MS   Memory Limit: 65536K
Total Submissions: 50827   Accepted: 22574

Description

A numeric sequence of ai is ordered if a1 < a2 < ... < aN. Let the subsequence of the given numeric sequence (a1a2, ..., aN) be any sequence (ai1ai2, ..., aiK), where 1 <= i1 < i2 < ... < iK <= N. For example, 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 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 file contains the length of sequence N. The second line contains the elements of sequence - N integers in the range from 0 to 10000 each, separated by spaces. 1 <= N <= 1000

Output

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

Sample Input

7
1 7 3 5 9 4 8

Sample Output

4

Source

Northeastern Europe 2002, Far-Eastern Subregion

 1 //2017-04-04
 2 #include <iostream>
 3 #include <cstdio>
 4 #include <cstring>
 5 #include <algorithm>
 6
 7 using namespace std;
 8
 9 const int N = 1005;
10 int dp[N], a[N];//dp[i]表示前i个数字的最长上升子序列
11
12 int main()
13 {
14     int n;
15     while(cin>>n)
16     {
17         for(int i = 0; i < n; i++)
18               cin>>a[i];
19         int mx = 0;
20         for(int i = 0; i < n; i++){
21             dp[i] = 1;
22             for(int j = 0; j < i; j++){
23                 if(a[j] < a[i])
24                       dp[i] = max(dp[i], dp[j]+1);
25             }
26             mx = max(mx, dp[i]);
27         }
28         cout<<mx<<endl;
29     }
30
31     return 0;
32 }
时间: 2024-10-22 08:48:19

POJ2533(KB12-N LIS)的相关文章

【动态规划+二分查找】POJ2533&amp;POJ1631最长上升子序列(LIS)

POJ2533裸的LIS,时间复杂度为O(n^2) 1 #include<iostream> 2 #include<cstdio> 3 using namespace std; 4 const int MAXN=1000+5; 5 int a[MAXN]; 6 int dp[MAXN]; 7 int n,ans; 8 9 int main() 10 { 11 scanf("%d",&n); 12 for (int i=0;i<n;i++) 13 {

DP总结 ——QPH

常见优化 单调队列 形式 dp[i]=min{f(k)} dp[i]=max{f(k)} 要求 f(k)是关于k的函数 k的范围和i有关 转移方法 维护一个单调递增(减)的队列,可以在两头弹出元素,一头压入元素. 队列中维护的是两个值.一个是位置,这和k的范围有关系,另外一个是f(k)的值,这个用来维护单调性,当然如果f(k)的值可以利用dp值在O(1)的时间内计算出来的话队列中可以只维护一个表示位置的变量. 枚举到一个i的时候,首先判断队首元素的位置是否已经不满足k的范围了,如果不满足就将队首

从零开始学动态规划

本文在写作过程中参考了大量资料,不能一一列举,还请见谅. 动态规划的定义: 动态规划是运筹学的一个分支,是求解决策过程的最优化的数学方法.20世纪50年代初美国数学家R.E.Bellman等人在研究多阶段决策过程的优化问题时,提出了著名的最优化原理,把多阶段过程转化为一系列单阶段问题,利用各阶段之间的关系,逐个求解,创立了解决这类过程优化问题的新方法--动态规划.在各种算法中,我认为动态规划是较难掌握好的,主要难在模型的建立. 解题的一般步骤是: 1.找出最优解的性质,刻画其结构特征和最优子结构

poj2533——lis(最长上升子序列), 线性dp

poj2533——lis(最长上升子序列), 线性dp Longest Ordered Subsequence Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 36143   Accepted: 15876 Description A numeric sequence of ai is ordered if a1 < a2 < ... < aN. Let the subsequence of the given n

poj2533 LIS

题目链接: http://poj.org/problem?id=2533 题意:第一个数n,接下来n个数,>  ....求最长上升子序列. 这道题有两种解法,第一种是通解,也适用于别的LIS. 代码1: #include<cstdio> #include<algorithm> using namespace std; int a[1005],dp[1005]; int main() { int n; while(scanf("%d",&n)==1)

动规(LIS)-POJ-2533

http://poj.org/problem?id=2533 Longest Ordered Subsequence 给定n个正整数,求最长上升子序列(LIS)长度(子序列中的元素不要求连续). 解题报告 思路 经典的LIS问题,O(n^2)的朴素做法不多作介绍,仅仅介绍O(n logn)的做法. 对于n个元素的数组array,建立一个数组d[n]. 其中d[i]表示长度为i的子序列中最小的末尾元素为d[i]. 数组d显然是升序的,可用反证法证明: 假设存在d[i]>=d[j]且i<j. 那么

POJ-2533.Longest Ordered Subsequence (LIS模版题)

本题大意:和LIS一样 本题思路:用dp[ i ]保存前 i 个数中的最长递增序列的长度,则可以得出状态转移方程dp[ i ] = max(dp[ j ] + 1)(j < i) 参考代码: 1 #include <iostream> 2 #include <cstring> 3 #include <algorithm> 4 using namespace std; 5 6 const int maxn = 1e3 + 5; 7 int a[maxn], dp[m

POJ 3903 Stock Exchange (LIS模版题)

题目跟poj2533一样,改一下数组大小完美A过. #include<cstdio> const int N = 100001; int a[N], f[N], d[N]; // d[i]用于记录a[0...i]的最大长度 int bsearch(const int *f, int size, const int &a) { int l=0, r=size-1; while( l <= r ){ int mid = (l+r)/2; if( a > f[mid-1] &am

最长上升子序列LIS解法(n^n &amp;&amp; nlogn)

最长递增子序列问题 在一列数中寻找一些数满足 任意两个数a[i]和a[j] 若i<j 必有a[i]<a[j] 这样最长的子序列称为最长递增子序列LIS LIS问题有两种常见的解法 一种时间复杂度n^n 一种时间复杂度nlogn 下面我们先来说一下n^n的算法 设dp[i]表示以i结尾的最长上升子序列的长度 把问题分解 分解成序列中每一项最为终点的最大上升子序列 从第二项开始依次判断 最后找出最大的一项就是答案 则状态转移方程为 dp[i] = max{dp[j]+1}, 1<=j<