CDQ解决一些三维偏序的问题

　　本来几天前就该记录的东西，硬生生被我拖到了现在，太懒了。。。

　　在cdq学习时，二维偏序已经解决了，无非就是先sort使第一维有序，然后再用cdq或者数据结构处理第二维。而三维偏序的时候呢，大佬的做法好像有树套树之类的，但是我不会，所以我选择cdq。

　　大体的思路很简单，首先也是先使第一维有序，然后cdq把第二维由小到大合并，这时再套个线段树或者树状数组处理第三维。来几题做一下

BZOJ1935园丁的烦恼

　　题目大意：一个花园里有n棵数，然后有m次询问，每次询问一个矩形里有多少颗树。

　　把原有的树视为更新操作，然后每个查询分为加上（0,0）到（x1-1,y1-1）范围内的树，减去（0,0）到（x1-1,y2）范围内的树，减去（0,0）到（x2,y1-1）范围内的树，加上（0,0）到（x2,y2）范围内的树，这样就可以处理一个二维前缀和，然后用cdq分治理套树状数组处理y轴

#include<cstdio>
#include<algorithm>
#define lowb(x) (x&(-x))
using namespace std;
const int N=500118,M=500118,Y=10000118,Q=(M<<2)+N;//每个查询分4个 
struct Nop{
    int x,y,op,w,id;
    friend bool operator < (const Nop &n1,const Nop &n2){
        return n1.x==n2.x ? n1.op<n2.op : n1.x<n2.x;
    }
}P[Q],temp[Q];
int pn,maxy,ans[M<<1],sumy[Y]={0};
void addp(int x,int y,int op,int w,int id){
    P[pn++]=(Nop){x,y,op,w,id};
}
void updata(int y)
{
    while(y<=maxy)
    {
        sumy[y]++;
        y+=lowb(y);
    }
}
int getsum(int y)
{
    int sum=0;
    while(y)
    {
        sum+=sumy[y];
        y-=lowb(y);
    }
    return sum;
}
void clear(int y)
{
    while(y<=maxy)
    {
        if(sumy[y])
            sumy[y]=0;
        else
            break;
        y+=lowb(y);
    }
}
void cdq(int l,int r)
{
    if(l==r)
        return ;
    int m=(l+r)>>1;
    cdq(l,m);
    cdq(m+1,r);
    int i=l,j=m+1,k=l;
    while(i<=m&&j<=r)
    {
        if(P[i]<P[j])
        {
            if(P[i].op==0)
                updata(P[i].y);
            temp[k++]=P[i++];
        }
        else
        {
            if(P[j].op==1)
                ans[P[j].id]+=P[j].w*getsum(P[j].y);
            temp[k++]=P[j++];
        }
    }
    while(i<=m)
        temp[k++]=P[i++];
    while(j<=r)
    {
        if(P[j].op==1)
            ans[P[j].id]+=P[j].w*getsum(P[j].y);
        temp[k++]=P[j++];
    }
    for(i=l;i<=r;i++)
    {
        clear(P[i].y);
        P[i]=temp[i];
    }
} 
int main()
{
    int n,m,x1,y1,x2,y2;
    while(~scanf("%d%d",&n,&m))
    {
        pn=maxy=0;
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&x1,&y1);
            x1++,y1++;
            addp(x1,y1,0,0,0);
            maxy=max(maxy,y1);
        }
        for(int i=0;i<m;i++)
        {
            ans[i]=0;
            scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
            x1++,y1++,x2++,y2++;
            //拆分成四个查询 
            addp(x1-1,y1-1,1,1,i);
            addp(x1-1,y2,1,-1,i);
            addp(x2,y1-1,1,-1,i);
            addp(x2,y2,1,1,i);
            maxy=max(maxy,max(y1,y2));
        }
        cdq(0,pn-1);
        for(int i=0;i<m;i++)
            printf("%d
",ans[i]);
    }
    return 0;
}

　　当然，这题很明显是个二维偏序问题，因为树本身都存在了，没有什么更新操作，直接离线树状数组处理就行。

#include<cstdio>
#include<algorithm>
#define lowb(x) (x&(-x))
using namespace std;
const int N=500118,M=500118,Y=10000118,Q=(M<<2)+N;
struct Nop{
    int x,y,op,w,id;
    friend bool operator < (const Nop &n1,const Nop &n2){
        return n1.x==n2.x ? n1.op<n2.op : n1.x<n2.x;
    }
}P[Q];
int pn,maxy,ans[M<<1],sumy[Y]={0};
void addp(int x,int y,int op,int w,int id){
    P[pn++]=(Nop){x,y,op,w,id};
}
void updata(int y)
{
    while(y<=maxy)
    {
        sumy[y]++;
        y+=lowb(y);
    }
}
int getsum(int y)
{
    int sum=0;
    while(y)
    {
        sum+=sumy[y];
        y-=lowb(y);
    }
    return sum;
}
void clear(int y)
{
    while(y<=maxy)
    {
        if(sumy[y])
            sumy[y]=0;
        else
            break;
        y+=lowb(y);
    }
}
int main()
{
    int n,m,x1,y1,x2,y2;
    while(~scanf("%d%d",&n,&m))
    {
        pn=maxy=0;
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&x1,&y1);
            x1++,y1++;
            addp(x1,y1,0,0,0);
            maxy=max(maxy,y1);
        }
        for(int i=0;i<m;i++)
        {
            ans[i]=0;
            scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
            x1++,y1++,x2++,y2++;
            addp(x1-1,y1-1,1,1,i);
            addp(x1-1,y2,1,-1,i);
            addp(x2,y1-1,1,-1,i);
            addp(x2,y2,1,1,i);
            maxy=max(maxy,max(y1,y2));
        }
        for(int i=1;i<=maxy;i++)
            clear(i);
        sort(P,P+pn);
        for(int i=0;i<pn;i++)
        {
            if(!P[i].op)
                updata(P[i].y);
            else
                ans[P[i].id]+=P[i].w*getsum(P[i].y);
        } 
        for(int i=0;i<m;i++)
            printf("%d
",ans[i]);
    }
    return 0;
}

BZOJ1176Mokia

　　题目大意：维护一个W*W的矩阵，初始值均为S.每次操作可以增加某格子的权值,或询问某子矩阵的总权值.修改操作数M<=160000,询问数Q<=10000,W<=2000000.

　　S值并没有实际作用忽略就好。这题就不行像上面那题单纯的离线然后树状数组维护就行了，因为是有着一个更新的存在，不同的查询前面的更新是不一样的。所以就是我们大体的思路，把每个操作视为（操作时间，x轴，y轴）这样的带有附加消息的三维有序对，这样第一维已经有序了，我们就只需要把x轴cdq分治处理，然后y轴有树状数组处理，查询也就是维护个二维的前缀和。

#include<cstdio>
#include<algorithm>
#define lowb(x) (x&(-x))
using namespace std;
const int N=160118,M=10118,Y=2001108,Q=(M<<2)+N;
struct Nop{
    int x,y,op,w,id;
    friend bool operator < (const Nop &n1,const Nop &n2){
        return n1.x==n2.x ? n1.op<n2.op : n1.x<n2.x;
    }
}P[Q],temp[Q];
int pn,qn,maxy,ans[M]={0},sum[Y]={0};
void addp(int x,int y,int op,int w,int id){
    P[pn++]=(Nop){x,y,op,w,id};
}
void updata(int y,int val)
{
    while(y<=maxy)
    {
        sum[y]+=val;
        y+=lowb(y);
    }
}
int getsum(int y)
{
    int ans=0;
    while(y)
    {
        ans+=sum[y];
        y-=lowb(y);
    }
    return ans;
}
void clear(int y)
{
    while(y<=maxy)
    {
        if(sum[y])
            sum[y]=0;
        else
            break;
        y+=lowb(y);
    }
}
void cdq(int l,int r)
{
    if(l==r)
        return ;
    int m=(l+r)>>1;
    cdq(l,m);
    cdq(m+1,r);
    int i=l,j=m+1,k=l;
    while(i<=m&&j<=r)
    {
        if(P[i]<P[j])
        {
            if(P[i].op==1)
                updata(P[i].y,P[i].w);
            temp[k++]=P[i++]; 
        }
        else
        {
            if(P[j].op==2)
                ans[P[j].id]+=P[j].w*getsum(P[j].y);
            temp[k++]=P[j++]; 
        }
    }
    while(i<=m)
        temp[k++]=P[i++];
    while(j<=r)
    {
        if(P[j].op==2)
            ans[P[j].id]+=P[j].w*getsum(P[j].y);
        temp[k++]=P[j++]; 
    }
    for(i=l;i<=r;i++)
    {
        clear(P[i].y);
        P[i]=temp[i];
    }
}
int main()
{
    int n,op,x1,y1,x2,y2,a;
    while(~scanf("%d%d",&n,&n))
    {
        pn=qn=maxy=0;
        while(scanf("%d",&op)&&op!=3)
        {
            if(op==1)
            {
                scanf("%d%d%d",&x1,&y1,&a);
                x1++,y1++;
                addp(x1,y1,op,a,0);
                maxy=max(maxy,y1);
            }
            else
            {
                scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
                x1++,y1++,x2++,y2++;
                addp(x1-1,y1-1,op,1,qn);
                addp(x1-1,y2,op,-1,qn);
                addp(x2,y1-1,op,-1,qn);
                addp(x2,y2,op,1,qn);
                qn++;
                maxy=max(maxy,max(y1,y2));
            }
        }
        cdq(0,pn-1);
        for(int i=0;i<qn;i++)
        {
            printf("%d
",ans[i]);
            ans[i]=0;
        }
    }
    return 0;
}

BZOJ3262陌上花开

　　题目大意：有n朵花,每朵花有三个属性:花形(s)、颜色(c)、气味(m),用三个整数表示。现在要对每朵花评级,一朵花的级别是它拥有的美丽能超过的花的数量。定义一朵花A比另一朵花B要美丽,当且仅Sa>=Sb,Ca>=Cb,Ma>=Mb。显然,两朵花可能有同样的属性。需要统计出评出每个等级的花的数量。

　　这就是个三维偏序的问题了，没有什么更新和查询就是（s,c,m）的三维有序对求顺序对，我们同样是让sort按s由小到大，s相同按c排，c相同按m排的cmp使得第一维s有序，然后cdq分治处理第二维c，树状数组维护第三维m，最后提交，好的，wrong了。因为一个重要的点，,两朵花可能有同样的属性，如果我们不去重的话，那么相同的属性的话，因为它们的顺序不同造成它们的等级不同。所以我们把属性相同的归为一类，然后统计这一类有多少个，然后作为树状数组维护的权值维护就行，有个小细节就是当分到最小的子区间也就是只有一朵花时，它的等级应该还得提升它的权值-1，因为那些和它属性相同的合为一类了，具体的就看代码注释。

#include<cstdio>
#include<algorithm>
#define lowb(x) (x&(-x))
using namespace std;
const int N=100118,K=200118;
struct Flower{
    int id,s,c,m,w;
    friend bool operator == (const Flower &f1,const Flower &f2){
        return f1.s==f2.s&&f1.m==f2.m&&f1.c==f2.c;
    }
}F[N],temp[N];
int fn,ans[N]={0},rank[N]={0},summ[K]={0};
//ans[i]保存编号为i的花的等级，也就是属性小于或等于它的数目 
bool cmp(const Flower &f1,const Flower &f2){
    return f1.s==f2.s ? (f1.c==f2.c ? f1.m<f2.m : f1.c<f2.c) : f1.s<f2.s;
}
void updata(int m,int val)
{
    while(m<=200000)
    {
        summ[m]+=val;
        m+=lowb(m);
    }
}
int getsum(int m)
{
    int ans=0;
    while(m)
    {
        ans+=summ[m];
        m-=lowb(m);
    }
    return ans;
}
void clear(int m)
{
    while(m<=200000)
    {
        if(summ[m]) 
            summ[m]=0;
        else
            break;
        m+=lowb(m);
    }
}
void cdq(int l,int r)
{
    if(l==r)
    {
        ans[F[l].id]+=F[l].w-1;//因为相同属性的归到一类了
        //所以还得加上F[l].w-1，也就是除它之外，
        //其他相同属性的花的数目 
        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(F[i].c<=F[j].c)
        {
            updata(F[i].m,F[i].w);
            temp[k++]=F[i++];
        }
        else
        {
            ans[F[j].id]+=getsum(F[j].m);
            temp[k++]=F[j++];
        }
    }
    while(i<=mid)
        temp[k++]=F[i++];
    while(j<=r)
    {
        ans[F[j].id]+=getsum(F[j].m);
        temp[k++]=F[j++];
    }
    for(i=l;i<=r;i++)
    {
        clear(F[i].m);
        F[i]=temp[i];   
    }
}
int main()
{
    int n,k;
    while(~scanf("%d%d",&n,&k))
    {
        for(int i=0;i<n;i++)
        {
            F[i].w=1;
            scanf("%d%d%d",&F[i].s,&F[i].c,&F[i].m);
        }
        sort(F,F+n,cmp);
        fn=0;
        //去重 
        for(int i=0;i<n;i++)
        {
            if(i&&F[i]==F[i-1])//如果和前一朵花属性相同，归到一类 
                F[fn-1].w++;
            else
            {
                F[fn]=F[i];
                F[fn].id=fn++;
            }
        }
        //原先n朵花去重就只有fn朵 
        cdq(0,fn-1);
        for(int i=0;i<fn;i++)
        {
            rank[ans[F[i].id]]+=F[i].w;
            ans[F[i].id]=0;
        }
        for(int i=0;i<n;i++)
        {
            printf("%d
",rank[i]);
            rank[i]=0;
        }
    }
    return 0;
}