四维偏序

我是萌萌的传送门

终于(算是)学会CDQ套CDQ了= =看来我对分治的理解还是不太深，要不然怎么会只会用CDQ压掉一维却不会压掉更高维呢……

题目就是个最简单的四维偏序，为了简化问题把四维都搞成了1~n的排列(废话，出题人可是我自己= =)，还把四维LIS换成了四维正序对(该是有多懒……)

四维偏序的话其实压力还是有点大的，首先O(nlog³n)的算法跟暴力差距真的不是特别大，不过经实测除了树套树套树速度和暴力差不多之外剩下的两种做法都是比较快的(经测试n=50000的数据暴力要跑大概6s+，好吧年代久远我忘了具体时间了)，所以时限开到2.5s，保证CDQ树套树和CDQ再CDQ都能稳过了。

言归正传。

CDQ树套树的做法很好想，就是对位置分治，这样就可以用扫描线把x压掉，只剩下y和z两维了。由于x已经用离线的扫描线压掉了，必须在线维护y和z，因此可以直接树套树(我写的是树状数组套替罪羊树，由于是随机数据替罪羊树还是很快的)。

#include<cstdio>
#include<cstring>
#include<algorithm>
#define siz(x) ((x)?((x)->size):(0))
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int maxn=50010;
const double A=0.65;
struct node{//Scapegoat Tree
    int data,size;
    node *lc,*rc,*prt;
    node(int d=0):data(d),size(1),lc(NULL),rc(NULL),prt(NULL){}
    inline void refresh(){size=siz(lc)+siz(rc)+1;}
}*root[maxn];
struct B{
    int id,a,b,c;
    bool operator<(const B &a)const{return this->a<a.a;}
}a[maxn],b[maxn];
void CDQ(int,int);
void add(int,int);
void del(int,int);
int query(int,int);
void insert(int);
void erase(int);
int rank(int);
node *insert(node*);
node *find(int);
node *erase(node*);
node *findmax(node*);
void rebuild(node*);
void zorder(node*);
void removetree(node*);
node *rebuild(int,int);
int n,T,cnt,data[maxn];
long long ans=0ll;
int main(){
#define MINE
#ifdef MINE
    freopen("partial_order.in","r",stdin);
    freopen("partial_order.out","w",stdout);
#endif
    scanf("%d",&n);
    for(int i=1;i<=n;i++)a[i].id=i;
    for(int i=1;i<=n;i++)scanf("%d",&a[i].a);
    for(int i=1;i<=n;i++)scanf("%d",&a[i].b);
    for(int i=1;i<=n;i++)scanf("%d",&a[i].c);
    CDQ(1,n);
    printf("%lld",ans);
#ifndef MINE
    printf("
-------------------------DONE-------------------------
");
    for(;;);
#endif
    return 0;
}
void CDQ(int l,int r){
    if(l>=r)return;
    int mid=(l+r)>>1;
    CDQ(l,mid);
    CDQ(mid+1,r);
    int i=l,j=mid+1,k=l;
    while(i<=mid&&j<=r){
        if(a[i]<a[j])b[k++]=a[i++];
        else b[k++]=a[j++];
    }
    while(i<=mid)b[k++]=a[i++];
    while(j<=r)b[k++]=a[j++];
    for(int i=l;i<=r;i++){
        a[i]=b[i];
        if(a[i].id<=mid)add(a[i].b,a[i].c);
        else ans+=query(a[i].b,a[i].c);
    }
    for(int i=l;i<=r;i++)if(a[i].id<=mid)del(a[i].b,a[i].c);
}
void add(int x,int d){
    while(x<=n){
        T=x;
        insert(d);
        x+=lowbit(x);
    }
}
void del(int x,int d){
    while(x<=n){
        T=x;
        erase(d);
        x+=lowbit(x);
    }
}
int query(int x,int d){
    int ans=0;
    while(x){
        T=x;
        ans+=rank(d);
        x-=lowbit(x);
    }
    return ans;
}
void insert(int x){
    node *rt=insert(new node(x));
    if(rt)rebuild(rt);
}
void erase(int x){
    node *rt=erase(find(x));
    if(rt)rebuild(rt);
}
int rank(int x){
    node *rt=root[T];
    int ans=0;
    while(rt){
        if(x<=rt->data)rt=rt->lc;
        else{
            ans+=siz(rt->lc)+1;
            rt=rt->rc;
        }
    }
    return ans;
}
node *insert(node *x){
    if(!root[T]){
        root[T]=x;
        return NULL;
    }
    node *rt=root[T];
    for(;;){
        if(x->data<rt->data){
            if(rt->lc)rt=rt->lc;
            else{
                rt->lc=x;
                break;
            }
        }
        else{
            if(rt->rc)rt=rt->rc;
            else{
                rt->rc=x;
                break;
            }
        }
    }
    x->prt=rt;
    x=NULL;
    for(;rt;rt=rt->prt){
        rt->refresh();
        if(max(siz(rt->lc),siz(rt->rc))>A*rt->size)x=rt;
    }
    return x;
}
node *find(int x){
    node *rt=root[T];
    while(rt){
        if(x==rt->data)return rt;
        else if(x<rt->data)rt=rt->lc;
        else rt=rt->rc;
    }
    return NULL;
}
node *erase(node *x){
    if(x->lc&&x->rc){
        node *y=findmax(x->lc);
        x->data=y->data;
        return erase(y);
    }
    if(!x->lc&&!x->rc){
        if(x->prt){
            if(x==x->prt->lc)x->prt->lc=NULL;
            else x->prt->rc=NULL;
        }
        else root[T]=NULL;
    }
    else if(x->lc&&!x->rc){
        x->lc->prt=x->prt;
        if(x->prt){
            if(x==x->prt->lc)x->prt->lc=x->lc;
            else x->prt->rc=x->lc;
        }
        else root[T]=x->lc;
    }
    else if(!x->lc&&x->rc){
        x->rc->prt=x->prt;
        if(x->prt){
            if(x==x->prt->lc)x->prt->lc=x->rc;
            else x->prt->rc=x->rc;
        }
        else root[T]=x->rc;
    }
    node *rt=x->prt;
    delete x;
    x=NULL;
    for(;rt;rt=rt->prt){
        rt->refresh();
        if(max(siz(rt->lc),siz(rt->rc))>A*rt->size)x=rt;
    }
    return x;
}
node *findmax(node *x){
    while(x->rc)x=x->rc;
    return x;
}
void rebuild(node *rt){
    cnt=0;
    zorder(rt);
    node *x=rebuild(1,cnt);
    x->prt=rt->prt;
    if(rt->prt){
        if(rt==rt->prt->lc)rt->prt->lc=x;
        else rt->prt->rc=x;
    }
    else root[T]=x;
    removetree(rt);
}
void removetree(node *x){
    if(!x)return;
    removetree(x->lc);
    removetree(x->rc);
    delete x;
}
void zorder(node *x){
    if(!x)return;
    zorder(x->lc);
    data[++cnt]=x->data;
    zorder(x->rc);
}
node *rebuild(int l,int r){
    if(l>r)return NULL;
    int mid=(l+r)>>1;
    node *x=new node(data[mid]);
    x->lc=rebuild(l,mid-1);
    if(x->lc)x->lc->prt=x;
    x->rc=rebuild(mid+1,r);
    if(x->rc)x->rc->prt=x;
    x->refresh();
    return x;
}

这里还有一份用pb_ds写的代码，你们要学会偷懒哈哈哈。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#define lowbit(x) ((x)&(-(x)))
using namespace std;
using namespace __gnu_pbds;
const int maxn=50010;
void CDQ(int,int);
void add(int,int);
void query(int,int);
void clear(int);
tree<int,null_mapped_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>T[maxn];
int n,x[maxn],y[maxn],z[maxn],a[maxn],b[maxn],ans=0;
bool cmp(int i,int j){return x[i]<x[j];}
int main(){
#define MINE
#ifdef MINE
    freopen("partial_order.in","r",stdin);
    freopen("partial_order.out","w",stdout);
#endif
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&x[i]);
    for(int i=1;i<=n;i++)scanf("%d",&y[i]);
    for(int i=1;i<=n;i++)scanf("%d",&z[i]);
    CDQ(1,n);
    printf("%d
",ans);
#ifndef MINE
    printf("
-------------------------DONE-------------------------
");
    for(;;);
#endif
    return 0;
}
void CDQ(int l,int r){
    if(l>=r)return;
    for(int i=l;i<=r;i++)a[i]=i;
    sort(a+l,a+r+1,cmp);
    int mid=(l+r)>>1;
    for(int i=l;i<=r;i++){
        if(a[i]<=mid)add(y[a[i]],z[a[i]]);
        else query(y[a[i]],z[a[i]]);
    }
    for(int i=l;i<=r;i++)if(a[i]<=mid)clear(y[a[i]]);
    CDQ(l,mid);
    CDQ(mid+1,r);
}
void add(int x,int d){
    while(x<=n){
        T[x].insert(d);
        x+=lowbit(x);
    }
}
void query(int x,int d){
    while(x){
        ans+=T[x].order_of_key(d);
        x-=lowbit(x);
    }
}
void clear(int x){
    while(x<=n&&!T[x].empty()){
        T[x].clear();
        x+=lowbit(x);
    }
}

然而树套树的常数很大，极限数据要跑大概1.1s~1.2s(本地和COGS都是这样)，并且树套树并不好写(当然你可以用树状数组套线段树来减少代码量)，所以可以再用一次分治压掉一维，剩下最后一维就可以直接树状数组搞掉了。

考虑每次外层的分治，我们都是计算左半部分与右半部分之间的正序对数目，而对x排序之后x已经有序了，剩下无序的y和z可以用树套树维护。既然位置是初始有序的，而x被我们排序后也有序了，我们就可以再对x分治，这样里层的分治就变成了统计位置和x都在左半的元素与位置和x都在右半的元素之间的正序对数量(x在同一半的情况会被里层分治递归解决)。这样处理之后就只剩下y和z了，用扫描线把y压掉，直接用树状数组维护z即可。

为了实现方便，把位置在前一半的元素标记为ins(插入)。a是原序列，b是把x排序之后里层分治用的序列。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=50010;
struct A{
    int x,y,z;
    bool ins;
}a[maxn],b[maxn];
void CDQ1(int,int);
void CDQ2(int,int);
void add(int,int);
int query(int);
bool cmpx(const A &x,const A &y){return x.x<y.x;}
bool cmpy(const A &x,const A &y){return x.y<y.y;}
int n,ans=0,c[maxn]={0};
int main(){
    freopen("partial_order.in","r",stdin);
    freopen("partial_order.out","w",stdout);
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i].x);
    for(int i=1;i<=n;i++)scanf("%d",&a[i].y);
    for(int i=1;i<=n;i++)scanf("%d",&a[i].z);
    CDQ1(1,n);
    printf("%d
",ans);
    return 0;
}
void CDQ1(int l,int r){
    if(l>=r)return;
    int mid=(l+r)>>1;
    CDQ1(l,mid);CDQ1(mid+1,r);
    for(int i=l;i<=mid;i++)a[i].ins=true;
    for(int i=mid+1;i<=r;i++)a[i].ins=false;
    sort(a+l,a+r+1,cmpx);//sort x
    copy(a+l,a+r+1,b+l);
    CDQ2(l,r);
}
void CDQ2(int l,int r){
    if(l>=r)return;
    int mid=(l+r)>>1;
    CDQ2(l,mid);CDQ2(mid+1,r);
    sort(b+l,b+mid+1,cmpy);
    sort(b+mid+1,b+r+1,cmpy);
    int i=l,j=mid+1;
    while(i<=mid&&j<=r){
        if(b[i].y<b[j].y){
            if(b[i].ins)add(b[i].z,1);
            i++;
        }
        else{
            if(!b[j].ins)ans+=query(b[j].z-1);
            j++;
        }
    }
    while(i<=mid){
        if(b[i].ins)add(b[i].z,1);
        i++;
    }
    while(j<=r){
        if(!b[j].ins)ans+=query(b[j].z-1);
        j++;
    }
    for(i=l;i<=mid;i++)if(b[i].ins)add(b[i].z,-1);
}
void add(int x,int d){
    while(x<=n){
        c[x]+=d;
        x+=x&-x;
    }
}
int query(int x){
    int ans=0;
    while(x){
        ans+=c[x];
        x&=x-1;
    }
    return ans;
}

还可以进一步优化，两层分治的排序都用归并排序，这样可以减小常数(对复杂度并没有影响)。t是里层的归并排序用的序列。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=50010;
struct A{
    int x,y,z;
    bool ins;
}a[maxn],b[maxn],t[maxn];
void CDQ1(int,int);
void CDQ2(int,int);
void add(int,int);
int query(int);
int n,ans=0,c[maxn]={0};
int main(){
    freopen("partial_order.in","r",stdin);
    freopen("partial_order.out","w",stdout);
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i].x);
    for(int i=1;i<=n;i++)scanf("%d",&a[i].y);
    for(int i=1;i<=n;i++)scanf("%d",&a[i].z);
    CDQ1(1,n);
    printf("%d
",ans);
    return 0;
}
void CDQ1(int l,int r){
    if(l>=r)return;
    int mid=(l+r)>>1;
    CDQ1(l,mid);CDQ1(mid+1,r);
    int i=l,j=mid+1,k=l;
    while(i<=mid&&j<=r){
        if(a[i].x<a[j].x){
            a[i].ins=true;
            b[k++]=a[i++];
        }
        else{
            a[j].ins=false;
            b[k++]=a[j++];
        }
    }
    while(i<=mid){
        a[i].ins=true;
        b[k++]=a[i++];
    }
    while(j<=r){
        a[j].ins=false;
        b[k++]=a[j++];
    }
    copy(b+l,b+r+1,a+l);
    CDQ2(l,r);
}
void CDQ2(int l,int r){
    if(l>=r)return;
    int mid=(l+r)>>1;
    CDQ2(l,mid);CDQ2(mid+1,r);
    int i=l,j=mid+1,k=l;
    while(i<=mid&&j<=r){
        if(b[i].y<b[j].y){
            if(b[i].ins)add(b[i].z,1);
            t[k++]=b[i++];
        }
        else{
            if(!b[j].ins)ans+=query(b[j].z-1);
            t[k++]=b[j++];
        }
    }
    while(i<=mid){
        if(b[i].ins)add(b[i].z,1);
        t[k++]=b[i++];
    }
    while(j<=r){
        if(!b[j].ins)ans+=query(b[j].z-1);
        t[k++]=b[j++];
    }
    for(i=l;i<=mid;i++)if(b[i].ins)add(b[i].z,-1);
    copy(t+l,t+r+1,b+l);
}
void add(int x,int d){
    while(x<=n){
        c[x]+=d;
        x+=x&-x;
    }
}
int query(int x){
    int ans=0;
    while(x){
        ans+=c[x];
        x&=x-1;
    }
    return ans;
}

这里是三种写法的对比(pb_ds就别贴了……)，不得不说CDQ的威力真是太强大了……

树套树：

CDQ(没有用归并排序优化)：

CDQ(归并排序)：

这个故事还告诉我们一个道理，写CDQ一定要用归并卡常……

 

话说我博客真是乱乱乱……我需要整理整理……