【typical】【JZOJ 5296】Sequence

Description

Analysis

努力寻找突破口，将第二步的排名变成实际的值域区间（通过主席树很容易维护），这样第二步就不受第一步约束，能简化问题。
我们将原本的位置视为一维，第一关键字视为第二维，第二关键字视为点权
那么每个询问就等价于求二维平面上某个矩阵内第k小点权值

分块^3

就是分块套分块套分块，这显然不是正解，但是是Samjia爷提供的一种思路Orz，由于我分块学得不好，不是特别懂

整体二分

关于CDQ分治与整体二分，很多人都不能分清它们（包括本Konjac），因为思想极其相似。网上看来的：cdq分治是用[l, mid]更新[mid+1,r]，整体二分根据[l,mid]来把询问的答案划分给[l,mid]或者[mid+1,r]

这个是我打的方法，也应该是比较好打的方法

对于当前答案mid，我们要判断当前集合中每个询问答案是在[l,mid]还是[mid+1,r]里面，那么只需统计该询问矩形内权值<=mid的点数，那么当前集合中的所有点只有权值<=mid的点有用（对询问造成贡献）

我们可以将所有点加入主席树，不过相当不优
由于分治结构，时间复杂度允许我们扫描集合中所有操作
而我们印象中又有：排序能降维
那么如果我们第一维已经排好序，并把询问拆成两个，就可以只用一个树状数组来维护了
$O(nlog^2n)$

二维数据结构

Crazy爷用这个方法过掉了Orz
树套树目前只会树状数组套其他树
二维中，行用树状数组维护，列用主席树维护
加入点很简单
查询的话，设行的范围是[x1,y1]，列的范围是[x2,y2]
还记得主席树上二分的套路吗？这道题，我们可以在树上二分答案区间，然后求出x1~y1的主席树中[x2,y2]中的点数和
[x2,y2]中的点数和可以事先记录好主席树中的root[x2-1]和root[y2]，信息相减得到
对于[x1,y1]这么多主席树，是以树状数组的特殊前缀结构套起来的，为了得到第x行的真实值，我们用树状数组中把x，x-lowbit(x)…..0 这么多个主席树的root[x2-1]和root[y2]记录下来
于是我们把行位置x1-1，y1通过上述方法记录下来，再信息相减，就能得到[x1,y1]的信息
时空复杂度均为$O(nlog^2n)$

Code

#include<cstdio>
#include<cstring>
#include<algorithm>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,b,a) for(int i=b;i>=a;i--)
#define max(x,y) ((x)>(y)?(x):(y))
#define min(x,y) ((x)<(y)?(x):(y))
#define mset(a,x) memset(a,x,sizeof(a))
using namespace std;
typedef long long ll;
char ch;
void read(int &n)
{
    n=0;int p=1;
    for(ch=getchar();ch<'0' || ch>'9';ch=getchar())
        if(ch=='-') p=-1;
    for(;'0'<=ch && ch<='9';ch=getchar()) n=n*10+ch-'0';
    n*=p;
}
const int N=3e4+5,M=2e5+5;
int tot,root[N],tr[M*18],ls[M*18],rs[M*18];
void ins(int u,int &v,int l,int r,int x)
{
    v=++tot;
    tr[v]=tr[u]+1,ls[v]=ls[u],rs[v]=rs[u];
    if(l==r) return;
    int mid=(l+r)>>1;
    if(x<=mid) ins(ls[u],ls[v],l,mid,x);
    else ins(rs[u],rs[v],mid+1,r,x);
}
int query(int u,int v,int l,int r,int k)
{
    if(l==r) return l;
    int mid=(l+r)>>1;
    if(k<=tr[ls[v]]-tr[ls[u]]) return query(ls[u],ls[v],l,mid,k);
    else return query(rs[u],rs[v],mid+1,r,k-(tr[ls[v]]-tr[ls[u]]));
}
int n,m,num,d[M],ans[M],BIT[N];
struct node
{
    int id,x,y;
}a[N];
struct op
{
    int id,l,r,x,y,z,k,tp;
}b[N+M],le[N+M],ri[N+M];
bool cmp(op a,op b){return a.x<b.x || a.x==b.x && !a.tp;}
int lowbit(int x){return x&-x;}
void add(int x,int y)
{
    for(;x<=n;x+=lowbit(x)) BIT[x]+=y;
}
int ask(int x)
{
    int t=0;
    for(;x;x-=lowbit(x)) t+=BIT[x];
    return t;
}
void divide(int p,int q,int l,int r)
{
    if(l==r)
    {
        fo(i,p,q)
            if(b[i].tp) ans[b[i].id]=l;
        return;
    }
    int mid=(l+r)>>1,le0=0,ri0=0;
    fo(i,p,q)
        if(b[i].tp) d[b[i].id]+=b[i].z*(ask(b[i].r)-ask(b[i].l-1));
        else
        if(b[i].z<=mid) add(b[i].y,1);
    fo(i,p,q)
        if(b[i].tp)
        {
            if(b[i].k<=d[b[i].id]) le[++le0]=b[i];
            else ri[++ri0]=b[i],ri[ri0].k-=d[b[i].id];
        }
        else
            if(b[i].z<=mid) le[++le0]=b[i];
            else ri[++ri0]=b[i];
    fo(i,p,q)
    {
        d[b[i].id]=0;
        if(!b[i].tp && b[i].z<=mid) add(b[i].y,-1);
    }
    fo(i,1,le0) b[p+i-1]=le[i];
    fo(i,1,ri0) b[p+le0-1+i]=ri[i];
    divide(p,p+le0-1,l,mid);
    divide(p+le0,q,mid+1,r);
}
int main()
{
    freopen("sequence.in","r",stdin);
    //freopen("sequence.out","w",stdout);
    read(n);
    fo(i,1,n)
    {
        read(a[i].x),a[i].id=i;
        ins(root[i-1],root[i],1,n,a[i].x);
    }
    fo(i,1,n)
    {
        read(a[i].y);
        b[++num].tp=0,b[num].x=i,b[num].y=a[i].x,b[num].z=a[i].y;
    }
    read(m);
    int l,r,x,y,k;
    fo(i,1,m)
    {
        read(l),read(r),read(x),read(y),read(k);
        x=query(root[l-1],root[r],1,n,x);
        y=query(root[l-1],root[r],1,n,y);
        b[++num].tp=1,b[num].x=l-1,b[num].l=x,b[num].r=y,b[num].z=-1,b[num].id=i,b[num].k=k;
        b[++num].tp=1,b[num].x=r,b[num].l=x,b[num].r=y,b[num].z=1,b[num].id=i,b[num].k=k;
    }
    sort(b+1,b+num+1,cmp);
    divide(1,num,1,n);
    fo(i,1,m) printf("%d\n",ans[i]);
    return 0;
}