LIS(最长上升子序列) (n*log2*n)

li 给定两个长度分别为n和m的序列，序列中的每个元素都是正整数。保证每个序列中

的各个元素互不相同。求这两个序列的最长公共子序列的长度。

 

 

 

解法2：贪心+二分：

思路：

新建一个 low 数组，low [ i ]表示长度为i的LIS结尾元素的最小值。对于一个上升子序列，显然其结尾元素越小，越有利于在后面接其他的元素，也就越可能变得更长。因此，我们只需要维护 low 数组，对于每一个a[ i ]，如果a[ i ] > low [当前最长的LIS长度]，就把 a [ i ]接到当前最长的LIS后面，即low [++当前最长的LIS长度] = a [ i ]。
那么，怎么维护 low 数组呢？
对于每一个a [ i ]，如果a [ i ]能接到 LIS 后面，就接上去；否则，就用 a [ i ] 取更新 low 数组。具体方法是，在low数组中找到第一个大于等于a [ i ]的元素low [ j ]，用a [ i ]去更新 low [ j ]。如果从头到尾扫一遍 low 数组的话，时间复杂度仍是O(n^2)。我们注意到 low 数组内部一定是单调不降的，所有我们可以二分 low 数组，找出第一个大于等于a[ i ]的元素。二分一次 low 数组的时间复杂度的O(lgn)，所以总的时间复杂度是O(nlogn)。

　　我们再举一个例子：有以下序列A[ ] = 3 1 2 6 4 5 10 7，求LIS长度。

　　我们定义一个B[ i ]来储存可能的排序序列，len 为LIS长度。我们依次把A[ i ]有序地放进B[ i ]里。

     （为了方便，i的范围就从1~n表示第i个数）

　　A[1] = 3，把3放进B[1]，此时B[1] = 3，此时len = 1，最小末尾是3

　　A[2] = 1，因为1比3小，所以可以把B[1]中的3替换为1，此时B[1] = 1，此时len = 1，最小末尾是1

　　A[3] = 2，2大于1，就把2放进B[2] = 2，此时B[ ]={1,2}，len = 2

　　同理，A[4]=6，把6放进B[3] = 6，B[ ]={1,2,6}，len = 3

　　A[5]=4，4在2和6之间，比6小，可以把B[3]替换为4，B[ ] = {1,2,4}，len = 3

　　A[6] = 5，B[4] = 5，B[ ] = {1,2,4,5}，len = 4

　　A[7] = 10，B[5] = 10，B[ ] = {1,2,4,5,10}，len = 5

　　A[8] = 7，7在5和10之间，比10小，可以把B[5]替换为7，B[ ] = {1,2,4,5,7}，len = 5

　　最终我们得出LIS长度为5。但是，但是！！这里的1 2 4 5 7很明显并不是正确的最长上升子序列。是的，B序列并不表示最长上升子序列，它只表示相应最长子序列长度的排好序的最小序列。这有什么用呢？我们最后一步7替换10并没有增加最长子序列的长度，而这一步的意义，在于记录最小序列，代表了一种“最可能性”。假如后面还有两个数据8和9，那么B[6]将更新为8，B[7]将更新为9，len就变为7，可以自行体会它的作用。

　　因为在B中插入的数据是有序的，不需要移动，只需要替换，所以可以用二分查找插入的位置，那么插入n个数的时间复杂度为〇(logn)，这样我们会把这个求LIS长度的算法复杂度降为了〇(nlogn)。话不多说了，show me the code！

code  map函数可以开够1000000000 的数组

//
#include<stdio.h>
#include<bits/stdc++.h>
using namespace std;
int f[400010];
int n,m;
int a1[400100],a2[400010];
map<int , int > pos;
int c[400010];
int lis[400010];
int tot;
int p;
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a1[i]);
        pos[a1[i]]=i;
    }
    for(int i=1;i<=m;i++)
    {
        scanf("%d",&a2[i]);
        if(pos[a2[i]]) c[++tot]=pos[a2[i]];
    }
    lis[1]=c[1];
    int le=1;
    for(int i=2;i<=tot;i++)
    {
        if(c[i]>lis[le]) lis[++le]=c[i];
        else
        {
            if(c[i]<=lis[le])  p=lower_bound(lis+1,lis+1+le,c[i])-lis;
            lis[p]=c[i];
        }
    }
    cout<<le;
    
    
}