题目大意

现在有N个盒子，初始为空。有M个操作，每个操作要么为编号范围在l~r的盒子都放入一个球上面的数为a，要么是询问编号范围在l~r的盒子所有球上的数的第k大值。
n,m<=50000

离线大法好

是不是很容易想到树套树？
我们这题是可以用整体二分或cdq分治的（我并不能分清它们）
具体做法如下：
用solve(l,r,S)表示现在处理S集合，S集合是操作集合按照时间排序，所有插入操作满足插入的球数值在l~r，所有询问操作满足其答案在区间l~r。
每个询问操作需要保存一个cnt代表目前在其询问的对应区间内>r的有多少个。
然后我们按顺序扫描操作。先记mid=(l+r)/2
对于插入操作，如果其插入的球数值>mid那么我们将对应区间加1（用线段树维护区间内mid+1~r的球个数）。然后根据其数值让其进入l~mid或mid+1~r。
对于询问操作，我们得到其区间内数值为mid+1~r的个数j，然后如果j+cnt<=k-1那么显然mid不可能是该询问的答案，将该询问进入l~mid并更新其的cnt否则进入mid+1~r。
然后做到l=r的时候就可以解决所有进入此区间的询问。
注意每次都有清空线段树，为了不超时需要打clear标记（或者打set标记）。当一个区间被下传了set标记时需要把所有值重置。注意down操作应该先解决set再解决add。
还有一个需要注意的细节那就是，因为l，r可能是负数，不能直接用(l+r)/2来得到mid，代码中mid=(l+r+2*n)/2-n，仔细想一想这是为什么？（提示：l=-2,r=-1）

#include<cstdio>
#include<algorithm>
#include<deque>
#define fo(i,a,b) for(i=a;i<=b;i++)
using namespace std;
const int maxn=50000+10;
struct dong{
    int id,b,c,cnt;
    bool p;
};
dong ask[maxn];
int tree[maxn*5],add[maxn*5],ans[maxn];
bool bz[maxn*5];
deque<int> dl[maxn*10];
int i,j,k,l,t,n,m;
void down(int p,int l,int r){
    int mid=(l+r)/2;
    if (bz[p]){
        bz[p]=0;
        bz[p*2]=1;
        add[p*2]=0;
        tree[p*2]=0;
        bz[p*2+1]=1;
        add[p*2+1]=0;
        tree[p*2+1]=0;
    }
    if (add[p]){
        tree[p*2]+=add[p]*(mid-l+1);
        add[p*2]+=add[p];
        tree[p*2+1]+=add[p]*(r-mid);
        add[p*2+1]+=add[p];
        add[p]=0;
    }
}
void change(int p,int r,int a,int b){
    if (l==a&&r==b){
        tree[p]+=(r-l+1);
        add[p]++;
        return;
    }
    down(p,r);
    int mid=(l+r)/2;
    if (b<=mid) change(p*2,mid,b);
    else if (a>mid) change(p*2+1,mid+1,b);
    else change(p*2,mid),change(p*2+1,b);
    tree[p]=tree[p*2]+tree[p*2+1];
}
int query(int p,int b){
    if (l==a&&r==b) return tree[p];
    down(p,r);
    int mid=(l+r)/2;
    if (b<=mid) return query(p*2,b);
    else if (a>mid) return query(p*2+1,b);
    else return query(p*2,mid)+query(p*2+1,b);
}
void solve(int p,int r){
    if (dl[p].empty()) return;
    if (l==r){
        int t;
        while (!dl[p].empty()){
            t=dl[p].front();
            dl[p].pop_front();
            if (ask[t].p) ans[t]=l;
        }
        return;
    }
    int mid=(l+r+2*n)/2-n,t;
    bz[1]=1;
    add[1]=0;
    tree[1]=0;
    while (!dl[p].empty()){
        t=dl[p].front();
        dl[p].pop_front();
        if (ask[t].p){
            j=query(1,1,ask[t].a,ask[t].b);
            if (ask[t].cnt+j<=ask[t].c-1){
                dl[p*2].push_back(t);
                ask[t].cnt+=j;
            }
            else dl[p*2+1].push_back(t);
        }
        else{
            if (ask[t].c>=mid+1){
                change(1,ask[t].b);
                dl[p*2+1].push_back(t);
            }
            else dl[p*2].push_back(t);
        }
    }
    solve(p*2,mid);
    solve(p*2+1,r);
}
int main(){
    scanf("%d%d",&n,&m);
    fo(i,m){
        scanf("%d%d%d%d",&t,&ask[i].a,&ask[i].b,&ask[i].c);
        if (t==2) ask[i].p=1;
        ask[i].id=i;
        dl[1].push_back(i);
    }
    solve(1,-n,n);
    fo(i,m)
        if (ask[i].p) printf("%dn",ans[i]);
}