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=,M=,Y=,Q=(M<<)+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<<],sumy[Y]={};
 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=;
     while(y)
     {
         sum+=sumy[y];
         y-=lowb(y);
     }
     return sum;
 }
 void clear(int y)
 {
     while(y<=maxy)
     {
         if(sumy[y])
             sumy[y]=;
         else
             break;
         y+=lowb(y);
     }
 }
 void cdq(int l,int r)
 {
     if(l==r)
         return ;
     int m=(l+r)>>;
     cdq(l,m);
     cdq(m+,r);
     int i=l,j=m+,k=l;
     while(i<=m&&j<=r)
     {
         if(P[i]<P[j])
         {
             if(P[i].op==)
                 updata(P[i].y);
             temp[k++]=P[i++];
         }
         else
         {
             if(P[j].op==)
                 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==)
             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=;
         for(int i=;i<n;i++)
         {
             scanf("%d%d",&x1,&y1);
             x1++,y1++;
             addp(x1,y1,,,);
             maxy=max(maxy,y1);
         }
         for(int i=;i<m;i++)
         {
             ans[i]=;
             scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
             x1++,y1++,x2++,y2++;
             //拆分成四个查询
             addp(x1-,y1-,,,i);
             addp(x1-,y2,,-,i);
             addp(x2,y1-,,-,i);
             addp(x2,y2,,,i);
             maxy=max(maxy,max(y1,y2));
         }
         cdq(,pn-);
         for(int i=;i<m;i++)
             printf("%d\n",ans[i]);
     }
     return ;
 }

园丁你为何烦恼呢

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

 #include<cstdio>
 #include<algorithm>
 #define lowb(x) (x&(-x))
 using namespace std;
 const int N=,M=,Y=,Q=(M<<)+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<<],sumy[Y]={};
 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=;
     while(y)
     {
         sum+=sumy[y];
         y-=lowb(y);
     }
     return sum;
 }
 void clear(int y)
 {
     while(y<=maxy)
     {
         if(sumy[y])
             sumy[y]=;
         else
             break;
         y+=lowb(y);
     }
 }
 int main()
 {
     int n,m,x1,y1,x2,y2;
     while(~scanf("%d%d",&n,&m))
     {
         pn=maxy=;
         for(int i=;i<n;i++)
         {
             scanf("%d%d",&x1,&y1);
             x1++,y1++;
             addp(x1,y1,,,);
             maxy=max(maxy,y1);
         }
         for(int i=;i<m;i++)
         {
             ans[i]=;
             scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
             x1++,y1++,x2++,y2++;
             addp(x1-,y1-,,,i);
             addp(x1-,y2,,-,i);
             addp(x2,y1-,,-,i);
             addp(x2,y2,,,i);
             maxy=max(maxy,max(y1,y2));
         }
         for(int i=;i<=maxy;i++)
             clear(i);
         sort(P,P+pn);
         for(int i=;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=;i<m;i++)
             printf("%d\n",ans[i]);
     }
     return ;
 }

园丁不烦恼了

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=,M=,Y=,Q=(M<<)+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]={},sum[Y]={};
 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=;
     while(y)
     {
         ans+=sum[y];
         y-=lowb(y);
     }
     return ans;
 }
 void clear(int y)
 {
     while(y<=maxy)
     {
         if(sum[y])
             sum[y]=;
         else
             break;
         y+=lowb(y);
     }
 }
 void cdq(int l,int r)
 {
     if(l==r)
         return ;
     int m=(l+r)>>;
     cdq(l,m);
     cdq(m+,r);
     int i=l,j=m+,k=l;
     while(i<=m&&j<=r)
     {
         if(P[i]<P[j])
         {
             if(P[i].op==)
                 updata(P[i].y,P[i].w);
             temp[k++]=P[i++];
         }
         else
         {
             if(P[j].op==)
                 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==)
             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=;
         while(scanf("%d",&op)&&op!=)
         {
             if(op==)
             {
                 scanf("%d%d%d",&x1,&y1,&a);
                 x1++,y1++;
                 addp(x1,y1,op,a,);
                 maxy=max(maxy,y1);
             }
             else
             {
                 scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
                 x1++,y1++,x2++,y2++;
                 addp(x1-,y1-,op,,qn);
                 addp(x1-,y2,op,-,qn);
                 addp(x2,y1-,op,-,qn);
                 addp(x2,y2,op,,qn);
                 qn++;
                 maxy=max(maxy,max(y1,y2));
             }
         }
         cdq(,pn-);
         for(int i=;i<qn;i++)
         {
             printf("%d\n",ans[i]);
             ans[i]=;
         }
     }
     return ;
 }

园丁都会了这个肯定会了

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=,K=;
 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]={},rank[N]={},summ[K]={};
 //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<=)
     {
         summ[m]+=val;
         m+=lowb(m);
     }
 }
 int getsum(int m)
 {
     int ans=;
     while(m)
     {
         ans+=summ[m];
         m-=lowb(m);
     }
     return ans;
 }
 void clear(int m)
 {
     while(m<=)
     {
         if(summ[m])
             summ[m]=;
         else
             break;
         m+=lowb(m);
     }
 }
 void cdq(int l,int r)
 {
     if(l==r)
     {
         ans[F[l].id]+=F[l].w-;//因为相同属性的归到一类了
         //所以还得加上F[l].w-1，也就是除它之外，
         //其他相同属性的花的数目
         return ;
     }
     int mid=(l+r)>>;
     cdq(l,mid);
     cdq(mid+,r);
     int i=l,j=mid+,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=;i<n;i++)
         {
             F[i].w=;
             scanf("%d%d%d",&F[i].s,&F[i].c,&F[i].m);
         }
         sort(F,F+n,cmp);
         fn=;
         //去重
         for(int i=;i<n;i++)
         {
             if(i&&F[i]==F[i-])//如果和前一朵花属性相同，归到一类
                 F[fn-].w++;
             else
             {
                 F[fn]=F[i];
                 F[fn].id=fn++;
             }
         }
         //原先n朵花去重就只有fn朵
         cdq(,fn-);
         for(int i=;i<fn;i++)
         {
             rank[ans[F[i].id]]+=F[i].w;
             ans[F[i].id]=;
         }
         for(int i=;i<n;i++)
         {
             printf("%d\n",rank[i]);
             rank[i]=;
         }
     }
     return ;
 } 

公子世无双