[tem]最长上升子序列

Longest Increasing Subsequence(LIS) 一个美丽的名字

非常经典的线性结构dp

[朴素]：O(n^2)

　　d(i)=max{0,d(j) :j<i&&a[j]<a[i]}+1

　　直接两个for

[二分查找优化]：O(nlogn)

　　g(i):d值为i的最小的a  每次更新然后lower_bound即可 ［大于等于］

lower_bound
Return iterator to lower bound
Returns an iterator pointing to the first element in the range [first,last) which does not compare less than val.

The elements are compared using operator< for the first version, and comp for the second. The elements in the range shall already be sorted according to this same criterion (operator< or comp), or at least partitioned with respect to val.

函数lower_bound()在first和last中的前闭后开区间进行二分查找，返回大于或等于val的第一个元素位置。如果所有元素都小于val，则返回last的位置，且last的位置是越界的

没有返回最后的下一个　　

g单调递增，所以可以二分

[线段树优化]：同上－－－－－实质：二维偏序问题

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－　　

[例题]比如 NOIP2004合唱队形

题目描述

N位同学站成一排，音乐老师要请其中的(N-K)位同学出列，使得剩下的K位同学排成合唱队形。

合唱队形是指这样的一种队形：设K位同学从左到右依次编号为1，2…，K，他们的身高分别为T1，T2，…，TK， 则他们的身高满足T1<...<Ti>Ti+1>…>TK(1<=i<=K)。

你的任务是，已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

正着一遍LIS，反着一遍LIS

 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 using namespace std;
 const int N=,INF=1e6;
 inline int read(){
     int x=,f=;
     char ch=getchar();
     while(ch<''||ch>''){if(ch=='-')f=-; ch=getchar();}
     while(ch>=''&&ch<=''){x=x*+ch-''; ch=getchar();}
     return x;
 }

 int n,d[N],g[N],a[N],f[N],ans=;

 void dp(){
     for(int i=;i<=n;i++) g[i]=INF;
     for(int i=;i<=n;i++){
         int k=lower_bound(g+,g++n,a[i])-g;//printf("%d d\n",k);
         d[i]=k;
         g[k]=a[i];
     }
     reverse(a+,a+n+);
     for(int i=;i<=n;i++) g[i]=INF;
     for(int i=;i<=n;i++){
         int k=lower_bound(g+,g++n,a[i])-g;//printf("%d f\n",k);
         f[i]=k;
         g[k]=a[i];
     }

 }
 int main() {
     n=read();
     for(int i=;i<=n;i++) a[i]=read();

     dp();
     for(int i=;i<=n;i++) ans=max(ans,f[n-i+]+d[i]-);
     printf("%d",n-ans);
     return ;
 }

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

Longest Decreasing Subsequence(LDS)   （不知道有没有这个名字）

也可以用二分，改一改，保留a最大的，找第一个小于等于的

 bool cmp(int a,int b){
     return a>b;
 }
 void lds(){
     for(int i=;i<=n;i++) g[i]=-INF;
     for(int i=;i<=n;i++){
         int k=lower_bound(g+,g++n,a[i],cmp)-g;
         f[i]=k;
         g[k]=a[i];
     }
 }

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

不上升，不下降

用upper_bound，找第一个大于的

 

 ［例题］

题目描述

某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭。由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。

输入导弹依次飞来的高度（雷达给出的高度数据是不大于30000的正整数），计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。

输入输出格式

输入格式：

一行，若干个正整数。

输出格式：

2行，每行一个整数，第一个数字表示这套系统最多能拦截多少导弹，第二个数字表示如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。

输入输出样例

输入样例#1：

389 207 155 300 299 170 158 65

输出样例#1：

6
2
-------------------------------------------------------------------------------------------------------------------------------------------
一遍最长不上升，一遍最长上升
（数据规模很小，但是练习一下nlogn）

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 using namespace std;
 const int N=,INF=1e7;
 int n=,a[N],g[N],d[N],f[N];
 bool cmp(int a,int b){
     return a>b;
 }
 void lds(){
     for(int i=;i<=n;i++) g[i]=-INF;

     for(int i=;i<=n;i++){
         int k=upper_bound(g+,g++n,a[i],cmp)-g;
         f[i]=k;
         g[k]=a[i];
     }
 }
 void lis(){
     for(int i=;i<=n;i++) g[i]=INF;

     for(int i=;i<=n;i++){
         int k=lower_bound(g,g++n,a[i])-g;
         d[i]=k;
         g[k]=a[i];
     }
 }

 int main(){
     while(cin>>a[++n]);n--;

     lds();lis();
     int _max=-INF;
     for(int i=;i<=n;i++) _max=max(_max,f[i]);
     printf("%d\n",_max);

     _max=-INF;
     for(int i=;i<=n;i++) _max=max(_max,d[i]);
     cout<<_max; 

 }