bzoj3173: [Tjoi2013]最长上升子序列

Description

给定一个序列，初始为空。现在我们将1到N的数字插入到序列中，每次将一个数字插入到一个特定的位置。每插入一个数字，我们都想知道此时最长上升子序列长度是多少？

Input

第一行一个整数N，表示我们要将1到N插入序列中，接下是N个数字，第k个数字Xk，表示我们将k插入到位置Xk（0<=Xk<=k-1,1<=k<=N）

Output

N行，第i行表示i插入Xi位置后序列的最长上升子序列的长度是多少。

Sample Input

3
0 0 2

Sample Output

1
1
2

HINT

100%的数据 n<=100000

Source

经过思考发现，由于是从小到大插入的，所以后插入的数对于先前插入的数没有影响，所以可以直接把最后的序列先求出来，再算一遍LIS就完了

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
const int maxn=100007;
int root;
int val[maxn];
int size1=0;
int rnd[maxn];
int size[maxn];
int ans[maxn];
int cnt=0;
int aa=0;
int tr[maxn][2];
void update(int k)
{
    size[k]=size[tr[k][0]]+size[tr[k][1]]+1;
}
void lturn(int &k){
    int t=tr[k][1];
    tr[k][1]=tr[t][0];
    tr[t][0]=k;
    update(k);
    update(t);
    k=t;
}
void rturn(int &k){
    int t=tr[k][0];
    tr[k][0]=tr[t][1];
    tr[t][1]=k;
    update(k);
    update(t);
    k=t;
}
void insert(int &k,int rank){
    if(k==0){
        k=++size1;
        size[k]=1;
        rnd[k]=rand();
        val[k]=++aa;
        return;
    }
    size[k]++;
    if(size[tr[k][0]]<rank)
    {
        insert(tr[k][1],rank-size[tr[k][0]]-1);
        if(rnd[tr[k][1]]<rnd[k]){
            lturn(k);
        }
    }
    else{
        insert(tr[k][0],rank);
        if(rnd[tr[k][0]]<rnd[k]){
            rturn(k);
        }
    }
}
void dfs(int x){
    if(!x) return;
    dfs(tr[x][0]);
    ans[++cnt]=val[x];
    dfs(tr[x][1]);
}
int g[maxn];
int d[maxn];
int main(){
    memset(g,127/3,sizeof(g));
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        int u;
        scanf("%d",&u);
        insert(root,u);
    }
    dfs(root);
    int ans1=0;
    for(int i=1;i<=n;i++)
    {
        int u=lower_bound(g+1,g+n+1,ans[i])-g;
        d[ans[i]]=u;
        g[u]=ans[i];
        ans1=max(ans1,u);
    }
    for(int i=1;i<=n;i++)
    {
        d[i]=max(d[i],d[i-1]);
        printf("%d\n",d[i]);
    }
    return 0;
}