BZOJ4066:简单题(K-D Tree)

Description

你有一个N*N的棋盘，每个格子内有一个整数，初始时的时候全部为0，现在需要维护两种操作：

 

命令	参数限制	内容
1 x y A	1<=x,y<=N，A是正整数	将格子x,y里的数字加上A
2 x1 y1 x2 y2	1<=x1<= x2<=N 1<=y1<= y2<=N	输出x1 y1 x2 y2这个矩形内的数字和
3	无	终止程序

Input

输入文件第一行一个正整数N。

接下来每行一个操作。每条命令除第一个数字之外，

均要异或上一次输出的答案last_ans，初始时last_ans=0。

Output

对于每个2操作，输出一个对应的答案。

Sample Input

4
1 2 3 3
2 1 1 3 3
1 1 1 1
2 1 1 0 7
3

Sample Output

3
5

HINT

数据规模和约定

1<=N<=500000,操作数不超过200000个，内存限制20M，保证答案在int范围内并且解码之后数据仍合法。

Solution

因为把1写成2挂了半天没找到错误ummm……
其他操作都是K-D Tree常规操作，唯一需要改改的就是查询的时候，
若当前KDT节点子树的矩形范围在查询范围外面就return
若当前KDT节点子树的矩形范围全在查询范围里面就统计子树答案return
记得判断一下查询的时候经过的叶子节点是否符合条件，符合则统计一下

Code

 #include<iostream>
 #include<cstring>
 #include<cstdlib>
 #include<cstdio>
 #include<cmath>
 #include<algorithm>
 #define N (200000+1000)
 using namespace std;

 int n,opt,x,y,X[],Y[],k,D,Root,ans,lastans;
 int stack[N],top,cnt;
 double alpha=0.75;

 int NewNode()
 {
     if (top) return stack[top--];
     return ++cnt;
 }

 struct Node
 {
     int d[],Max[],Min[],lson,rson,sum,val,size;
     bool operator < (const Node &a) const {return d[D]<a.d[D];}
     Node (int x=,int y=,int z=)
     {
         d[]=x; d[]=y; lson=rson=; sum=val=z; size=;
         Max[]=Min[]=d[]; Max[]=Min[]=d[];
     }
 }p[N];

 struct KDT
 {
     Node Tree[N];

     void Update(int now)
     {
         int ls=Tree[now].lson, rs=Tree[now].rson;
         for (int i=; i<=; ++i)
         {
             Tree[now].Max[i]=Tree[now].Min[i]=Tree[now].d[i];
             if (ls)
             {
                 Tree[now].Max[i]=max(Tree[now].Max[i],Tree[ls].Max[i]);
                 Tree[now].Min[i]=min(Tree[now].Min[i],Tree[ls].Min[i]);
             }
             if (rs)
             {
                 Tree[now].Max[i]=max(Tree[now].Max[i],Tree[rs].Max[i]);
                 Tree[now].Min[i]=min(Tree[now].Min[i],Tree[rs].Min[i]);
             }
         }
         Tree[now].sum=Tree[ls].sum+Tree[rs].sum+Tree[now].val;
         Tree[now].size=Tree[ls].size+Tree[rs].size+;
     }
     int Build(int opt,int l,int r)
     {
         if (l>r) return ;
         int mid=(l+r)>>, now=NewNode();
         D=opt; nth_element(p+l,p+mid,p+r+);
         Tree[now]=p[mid];
         Tree[now].lson=Build(opt^,l,mid-);
         Tree[now].rson=Build(opt^,mid+,r);
         Update(now); return now;
     }
     void Dfs(int now,int num)
     {
         int ls=Tree[now].lson, rs=Tree[now].rson;
         if (ls) Dfs(ls,num);
         p[num+Tree[ls].size]=Tree[now]; stack[++top]=now;
         if (rs) Dfs(rs,num+Tree[ls].size+);
     }
     void Check(int &now,int opt)
     {
         int ls=Tree[now].lson, rs=Tree[now].rson;
         if (Tree[ls].size>Tree[now].size*alpha || Tree[rs].size>Tree[now].size*alpha)
             Dfs(now,), now=Build(opt,,Tree[now].size);
     }
     void Insert(int &now,int x,int opt)
     {
         if (now==){Root=x; return;}
         if (Tree[x].d[opt]<=Tree[now].d[opt])
         {
             if (Tree[now].lson) Insert(Tree[now].lson,x,opt^);
             else Tree[now].lson=x;
         }
         else
         {
             if (Tree[now].rson) Insert(Tree[now].rson,x,opt^);
             else Tree[now].rson=x;
         }
         Update(now); Check(now,opt);
     }
     void Query(int now)
     {
         if (Tree[now].Max[]<X[] || Tree[now].Max[]<Y[] || Tree[now].Min[]>X[] || Tree[now].Min[]>Y[]) return;
         if (Tree[now].Max[]<=X[] && Tree[now].Min[]>=X[] && Tree[now].Max[]<=Y[] && Tree[now].Min[]>=Y[])
         {
             ans+=Tree[now].sum;
             return;
         }
         if (Tree[now].d[]<=X[] && Tree[now].d[]>=X[] && Tree[now].d[]<=Y[] && Tree[now].d[]>=Y[]) ans+=Tree[now].val;
         if (Tree[now].lson) Query(Tree[now].lson);
         if (Tree[now].rson) Query(Tree[now].rson);
     }
 }KDT;

 int main()
 {
     scanf("%d",&n);
     while ()
     {
         scanf("%d",&opt);
         if (opt==)
         {
             scanf("%d%d%d",&x,&y,&k);
             x^=lastans; y^=lastans; k^=lastans;
             int t=NewNode();
             KDT.Tree[t]=Node(x,y,k);
             KDT.Tree[t].size=;
             KDT.Insert(Root,t,);
         }
         if (opt==)
         {
             scanf("%d%d%d%d",&X[],&Y[],&X[],&Y[]);
             X[]^=lastans; Y[]^=lastans;
             X[]^=lastans; Y[]^=lastans;
             ans=;
             KDT.Query(Root);
             printf("%d\n",ans);
             lastans=ans;
         }
         if (opt==) break;
     }
 }