HDU-6703 array（主席树）

题意：给出一个序列，保证序列是一个1~n的全排列，q次操作，两种类型，一是给$a[i]$加$10^7$，另一种是给出r，k，询问一个最小的数字x，使得$x>=k$，x不等于区间[1,r]内的任何一个数字，强制在线，数据范围：$n,m<=10^5,k<=n$

首先观察数据发现查询的答案最多为n+1，对于操作1来说，给一个数字加一个超大的数字，是不是说明，这个数字之后就不会再出现了，他是不是就可以作为查询的答案之一了。
再考虑序列是一个1~n的全排列，那么是不是说明$[1,r]$内出现过的数字，在区间$[r+1,n]$内都不会出现了。
所以序列从后往前向主席树中添加数字，对于操作1如果这个数字被修改了就放到set中，那对于查询操作，是不是查询$[r+1,n]$的主席树中大于等于k的最小值，set中大于等于k的最小值两者取最小即可。
为了查询的方便，同时维护一个区间最大数字。
比赛开始，队友给我翻译了这道题，我从开始做到结束，一直想不到好的维护方法，以为人均会树套树维护奇怪的东西，赛后才发现我忽略了最重要的东西：保证序列是一个1~n的全排列，以后还是应该自己看题啊。

#include
using namespace std;

const int maxn=1e5+7;
const int maxm=1e5+7;
const int inf=0x3f3f3f3f;
typedef long long ll;

int tot;

int a[maxn];

struct Tree{
     
    int sum;
    int lc,rc;
    int maxx;
}tree[maxn*30];

int root[maxn];

int build(int l,int r){
     
    int k=++tot;
    tree[k].sum=tree[k].maxx=0;
    if(l==r) return k;
    int mid=(l+r)>>1;
    tree[k].lc=build(l,mid);
    tree[k].rc=build(mid+1,r);
    return k;
}

int updata(int p,int l,int r,int id,int val){
     
    int k=++tot;
    tree[k]=tree[p];
    if(l==r){
     
        tree[k].sum++;
        tree[k].maxx=id;
        return k;
    }
    int mid=(l+r)>>1;
    if(id<=mid) tree[k].lc=updata(tree[p].lc,l,mid,id,val);
    else tree[k].rc=updata(tree[p].rc,mid+1,r,id,val);
    tree[k].sum=tree[tree[k].lc].sum+tree[tree[k].rc].sum;
    tree[k].maxx=max(tree[tree[k].lc].maxx,tree[tree[k].rc].maxx);
    return k;
}

int n;
int myfind(int p,int l,int r,int k){
     
    if(l==r){
     
        if(tree[p].sum&&l>=k) return l;
        return n+5;
    }
    int mid=(l+r)>>1;
    if(tree[p].maxx<k) return n+5;
    if(k<=mid&&tree[tree[p].lc].maxx>=k) return myfind(tree[p].lc,l,mid,k);
    return myfind(tree[p].rc,mid+1,r,k);
}

set<int> s;
bool vis[maxn];
int main(){
     
    int m,t,k,l,r,id;
    scanf("%d",&t);
    while(t--){
     
        tot=0;
        scanf("%d%d",&n,&m);
        s.clear();
        s.insert(n+1);
        int res=0;
        for(int i=1;i<=n;++i) scanf("%d",&a[i]);
        root[n+1]=build(1,n);
        for(int i=n;i>=1;--i) root[i]=updata(root[i+1],1,n,a[i],1);

        while(m--){
     
            scanf("%d",&id);
            if(id==1){
     
                scanf("%d",&l);
                l^=res;
                if(vis[l]) continue;
                s.insert(a[l]);
                vis[l]=1;
            }
            else{
     
                scanf("%d%d",&r,&k);
                r^=res,k^=res;
                res=min(myfind(root[r+1],1,n,k),(*(s.lower_bound(k))));
                printf("%d\n",res);
            }
        }
        for(int i=1;i<=n;++i) vis[i]=0;
    }

    return 0;
}

题解的做法，可以建立一个值域为$[1,n+1]$的权值线段树，维护值域区间内最大的下标，那么查询操作转化成了查询值域区间$[k,n+1]$内位置大于r的最小值。修改操作的话可以将$a[l]$处的位置改成n+1，就可以保证答案的正确性了。
比我的主席树高明多了23333。

#include
using namespace std;

const int maxn=1e5+7;
const int maxm=1e5+7;
const int inf=0x3f3f3f3f;
typedef long long ll;

int maxx[maxn<<2|1];

void build(int l,int r,int k){
     
    maxx[k]=0;
    if(l==r) return ;
    int mid=(l+r)>>1;
    build(l,mid,k<<1);
    build(mid+1,r,k<<1|1);
}

void updata(int l,int r,int k,int id,int pos){
     
    if(l==r){
     
        maxx[k]=pos;
        return ;
    }
    int mid=(l+r)>>1;
    if(id<=mid) updata(l,mid,k<<1,id,pos);
    else updata(mid+1,r,k<<1|1,id,pos);
    maxx[k]=max(maxx[k<<1],maxx[k<<1|1]);
}

int myfind(int l,int r,int k,int val,int pos){
     
    if(l==r){
     
        if(maxx[k]>=pos) return l;
        return -1;
    }
    int mid=(l+r)>>1;
    int res=-1;
    if(val<=mid&&maxx[k<<1]>=pos) res=myfind(l,mid,k<<1,val,pos);
    if(res==-1) return myfind(mid+1,r,k<<1|1,val,pos);
    return res;
}
int a[maxn];
int main(){
     
    int t,n,m,l,r,k,x,id;
    scanf("%d",&t);
    while(t--){
     
        scanf("%d%d",&n,&m);
        build(1,n+1,1);
        for(int i=1;i<=n;++i){
     
            scanf("%d",&a[i]);
            updata(1,n+1,1,a[i],i);
        }
        updata(1,n+1,1,n+1,n+1);
        int res=0;
        while(m--){
     
            scanf("%d",&id);
            if(id==1){
     
                scanf("%d",&l);
                l^=res;
                updata(1,n+1,1,a[l],n+1);
            }
            else{
     
                scanf("%d%d",&r,&k);
                r^=res;
                k^=res;
                printf("%d\n",res=myfind(1,n+1,1,k,r+1));

            }
        }
    }
    return 0;
}