树套树

1.bzoj1146
树上支持两种操作：
1.更改点权
2.求某链上第k大的值，如果不存在第k大的值，输出一串字符
解法：首先，树链剖分+线段树将整棵树划分开来。然后在线段树中的每个节点插入一个平衡树。
我们知道以下方法：
多组询问[l,r]区间第k大的值，支持单点更新，可以用线段树+平衡树解决。
具体方法是二分第k大值X，利用线段树+平衡树可以求出区间内大于X的个数和，利用此值可以二分求出区间第k大值。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N maxn
#define PII pair<int,int>
#include<map>
#include<vector>
#define MP make_pair
#include<map>
#include<bitset>
#define ll int
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
using namespace std;

const int maxn = 100000+10;
int n,q,w[maxn];
vector<int> g[maxn];
int f[maxn],d[maxn],num[maxn],id[maxn],fid[maxn],tp[maxn],son[maxn],p;
//L_W
void dfs1(int u,int fa,int dep){
    f[u]=fa,num[u]=1,d[u]=dep;
    int tn=0;
    for(int i=0;i<g[u].size();i++){
        int v=g[u][i];
        if(v==fa) continue;
        dfs1(v,u,dep+1);
        num[u]+=num[v];
        if(num[v]>tn) { tn=num[v]; son[u]=v; }
    }
}
void dfs2(int u,int tpu){
    tp[u]=tpu,id[u]=++p,fid[p]=u;
    if(son[u]!=-1) dfs2(son[u],tpu);
    for(int i=0;i<g[u].size();i++){
        int v=g[u][i];
        if(v==f[u]||v==son[u]) continue;
        dfs2(v,v);
    }
}

//Treap
struct data{
    int l,r,v,sz,rnd,w;
}tr[maxn<<2];
int sz,root[maxn<<2];
int trank;
void update(int k){
    tr[k].sz=tr[tr[k].l].sz+tr[tr[k].r].sz+tr[k].w;
}
void lturn(int &k){
    int t=tr[k].r; tr[k].r=tr[t].l; tr[t].l=k;
    update(k),update(t),k=t;
}
void rturn(int &k){
    int t=tr[k].l; tr[k].l=tr[t].r; tr[t].r=k;
    update(k),update(t),k=t;
}
void Insert(int &k,int x){
    if(!k){
        k=++sz;
        tr[k].sz=tr[k].w=1; tr[k].v=x,tr[k].rnd=rand();
        return;
    }
    tr[k].sz++;
    if(x==tr[k].v) tr[k].w++;
    else if(x>tr[k].v){
        Insert(tr[k].r,x);
        if(tr[tr[k].r].rnd<tr[k].rnd) lturn(k);
    }
    else{
        Insert(tr[k].l,x);
        if(tr[tr[k].l].rnd<tr[k].rnd) rturn(k);
    }
}
void del(int &k,int x){
    if(!k) return;
    if(tr[k].v==x){
        if(tr[k].w>1){ tr[k].w--; tr[k].sz--; return; }
        if(tr[k].l*tr[k].r==0) k=tr[k].l+tr[k].r;
        else if(tr[tr[k].l].rnd<tr[tr[k].r].rnd) rturn(k),del(k,x);
        else lturn(k),del(k,x);
    }
    else if(x>tr[k].v) del(tr[k].r,x),tr[k].sz--;
    else del(tr[k].l,x),tr[k].sz--;
}
void query_rank(int k,int x){//有几个元素比x大
    if(!k) return;
    if(tr[k].v==x) trank+=tr[tr[k].r].sz;
    else if(x<tr[k].v) { trank+=(tr[tr[k].r].sz+tr[k].w); query_rank(tr[k].l,x); }
    else query_rank(tr[k].r,x);
}
//Segment_Tree
void change(int id,int x,int y,int l,int r,int rt){
    del(root[rt],x),Insert(root[rt],y);
    if(l==r) return;
    int m=(l+r)>>1;
    if(id<=m) change(id,x,y,lson);
    else change(id,x,y,rson);
}
void query(int L,int R,int num,int l,int r,int rt){
    if(L<=l&&r<=R){
        query_rank(root[rt],num);
        return;
    }
    int m=(l+r)>>1;
    if(L<=m) query(L,R,num,lson);
    if(R>m) query(L,R,num,rson);
}

void getrank(int u,int v,int x){
    while(tp[u]!=tp[v]){
        if(d[tp[u]]>d[tp[v]]) swap(u,v);
        query(id[tp[v]],id[v],x,1,n,1);
        v=f[tp[v]];
    }
    if(d[u]>d[v]) swap(u,v);
    query(id[u],id[v],x,1,n,1);
}

int K[maxn],a[maxn],b[maxn];
vector<int> has;
void solve(int u,int v,int K){
    trank=0,getrank(u,v,0);
    //printf("%d %da\n",trank,K);
    int ans=-1;
    if(trank-1<K){
        printf("invalid request!\n");return;
    }
    int l=1,r=has.size();
    while(l<=r){
        int m=(l+r)>>1;
        trank=0;
        getrank(u,v,m);
        if(trank+1<=K) { ans=m,r=m-1; }
        else l=m+1;
    }
    printf("%d\n",has[ans-1]);
}

int main(){
    //freopen("a.txt","r",stdin);
    while(scanf("%d%d",&n,&q)!=EOF){
        has.clear();
        for(int i=1;i<=n;i++) { scanf("%d",&w[i]); g[i].clear(); has.push_back(w[i]); }
        int k,x,y;
        for(int i=1;i<=n-1;i++){
            scanf("%d%d",&x,&y);
            g[x].push_back(y),g[y].push_back(x);
        }
        memset(son,-1,sizeof(son)); p=0;
        dfs1(1,0,0),dfs2(1,1);
        sz=0;
        memset(root,0,sizeof(root));
        for(int i=1;i<=q;i++){
            scanf("%d%d%d",&K[i],&a[i],&b[i]);
            if(!K[i]) has.push_back(b[i]);
        }
        sort(has.begin(),has.end());
        has.erase(unique(has.begin(),has.end()),has.end());
        for(int i=1;i<=n;i++) w[i]=lower_bound(has.begin(),has.end(),w[i])-has.begin()+1;
        for(int i=1;i<=q;i++){
            if(!K[i]) b[i]=lower_bound(has.begin(),has.end(),b[i])-has.begin()+1;
        }
        for(int i=1;i<=n;i++) change(id[i],0,w[i],1,n,1);
        for(int i=1;i<=q;i++){
            if(!K[i]) { change(id[a[i]],w[a[i]],b[i],1,n,1); w[a[i]]=b[i]; }
            else solve(a[i],b[i],K[i]);
        }
    }
    return 0;
}