疯狂求导 [树套树]

题面

思路

首先，显然这里求$k$阶导就是钦点只有$[k,inf]$次的项是有效的

注意：本题同类项不合并

如果合并的话我还真的不会做......合并相当于强制在线莫队，我想过各种鬼畜的算法但是都挂掉了= =||

但是如果不合并的话就比较好做了

我们开一棵权值线段树套位置线段树

权值线段树区间$[val_left,val_right]$下位置线段树区间$[pos_left,pos_right]$中保存这个区间里面有多少个在这个权值区间里面的项

这样，每次修改就是上层单点下层区间，上层不用pushdown，单次时间效率$O(\log n\log1e6)$

下层树中就是一个动态开点的区间修改区间查询，pushdown记得开新点

查询的时候就是在上层线段树中二分，每次查询当前右儿子下属下层线段树的对应区间的值是不是比要求的大

空间效率$O(\log n\log 1e6)$，但是空间限制$1G$，随便造，不担心

Code

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cassert>
#define ll long long
using namespace std;
inline ll read(){
    ll re=0,flag=1;char ch=getchar();
    while(ch>'9'||ch<'0'){
        if(ch=='-') flag=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9') re=(re<<1)+(re<<3)+ch-'0',ch=getchar();
    return re*flag;
}
int rt[4000010],cnt,ch[40000010][2],lazy[40000010];ll siz[40000010];
int n,m;
int UPPERql,UPPERqr,UPPERqql,UPPERqqr,LOWERql,LOWERqr;
void push(int l,int r,int cur){//下层pushdown
    if(l==r||!lazy[cur]) return;
    int mid=(l+r)>>1;
    if(!ch[cur][0]) ch[cur][0]=++cnt;
    siz[ch[cur][0]]+=(mid-l+1)*lazy[cur];lazy[ch[cur][0]]+=lazy[cur];
    if(!ch[cur][1]) ch[cur][1]=++cnt;
    siz[ch[cur][1]]+=(r-mid)*lazy[cur];lazy[ch[cur][1]]+=lazy[cur];
    lazy[cur]=0;
}
void change(int l,int r,int &cur){//下层修改
    if(!cur) cur=++cnt;
    if(l>=LOWERql&&r<=LOWERqr){siz[cur]+=(r-l+1);lazy[cur]++;return;}
    push(l,r,cur);
    int mid=(l+r)>>1;
    if(mid>=LOWERql) change(l,mid,ch[cur][0]);
    if(mid<LOWERqr) change(mid+1,r,ch[cur][1]);
    siz[cur]=siz[ch[cur][0]]+siz[ch[cur][1]];
}
void changert(int l,int r,int num,int pos){//上层修改
    LOWERql=UPPERql;LOWERqr=UPPERqr;
    change(1,n,rt[num]);
    if(l==r) return;
    int mid=(l+r)>>1;
    if(mid>=pos) changert(l,mid,num<<1,pos);
    if(mid<pos) changert(mid+1,r,num<<1|1,pos);
}
ll query(int l,int r,int cur){//下层查询
    if(!cur) return 0;
    if(l>=LOWERql&&r<=LOWERqr) return siz[cur];
    push(l,r,cur);
    int mid=(l+r)>>1;ll re=0;
    if(mid>=LOWERql) re+=query(l,mid,ch[cur][0]);
    if(mid<LOWERqr) re+=query(mid+1,r,ch[cur][1]);
    return re;
}
int getans(int l,int r,int num,ll lim){//上层中二分
    if(l==r) return l;
    LOWERql=UPPERql;LOWERqr=UPPERqr;
    ll tmp=query(1,n,rt[num<<1|1]);int mid=(l+r)>>1;
    if(tmp>lim) return getans(mid+1,r,num<<1|1,lim);
    else return getans(l,mid,num<<1,lim-tmp);
}
ll get(int l,int r,int num){//上层查询
    if(!rt[num]) return 0;
    if(l>=UPPERql&&r<=UPPERqr){LOWERql=UPPERqql;LOWERqr=UPPERqqr;return query(1,n,rt[num]);}
    int mid=(l+r)>>1;ll re=0;
    if(mid>=UPPERql) re+=get(l,mid,num<<1);
    if(mid<UPPERqr) re+=get(mid+1,r,num<<1|1);
    return re;
}
int main(){
    n=read();m=read();ll i,t1,t2,t3,t4,lastp=0,tmp;
    for(i=1;i<=n;i++){
        t1=read();
    }
    while(m--){
        t4=read();t1=read();t2=read();t3=read();
        if(t4){
            UPPERql=t1;UPPERqr=t2;
            tmp=getans(1,1000001,1,t3);
            lastp=tmp;
            UPPERql=tmp+1;UPPERqr=1000001;UPPERqql=t1;UPPERqqr=t2;
            printf("%lld %lld\n",tmp,get(1,1000001,1));
        }
        else{
            t3^=lastp;UPPERql=t1;UPPERqr=t2;
            changert(1,1000001,1,t3+1);
        }
    }
}