【BZOJ】【4066】简单题（强制在线）

KD-Tree

---

　　KD-Tree的进阶姿势戳这里 http://zyfzyf.is-programmer.com/posts/92431.html

　　为啥有种线段树&平衡树的即视感……（树形结构的相似性？）

　　每次插入之后，判断下如果某个子树的size>父亲size*0.7，那么重构一下……（替罪羊树的即视感）

　　查询的时候，如果当前点表示的坐标范围被查询范围完全包含，则直接返回sum；

　　否则：当前点若在范围内则更新答案，左子树若不全在范围外则递归进入查询，右子树同理（线段树的即视感）

　　

TLE：rebuild的时候，我没清当前点的min和max就直接build子树&Push_up(o)了……活该跪……

UPD：2015-05-23 17:20:26

　　今天看论文的时候，发现这一做法在陈老师的论文中已经讲出来了……orz，无限ym陈老师！

 /**************************************************************
     Problem: 4066
     User: Tunix
     Language: C++
     Result: Accepted
     Time:28400 ms
     Memory:11444 kb
 ****************************************************************/
 
 //BZOJ 4066
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<iostream>
 #include<algorithm>
 #define rep(i,n) for(int i=0;i<n;++i)
 #define F(i,j,n) for(int i=j;i<=n;++i)
 #define D(i,j,n) for(int i=j;i>=n;--i)
 #define pb push_back
 using namespace std;
 typedef long long LL;
 inline int getint(){
     int r=,v=; char ch=getchar();
     for(;!isdigit(ch);ch=getchar()) if (ch=='-') r=-;
     for(; isdigit(ch);ch=getchar()) v=v*-''+ch;
     return r*v;
 }
 const int N=,INF=1e9;
 /*******************template********************/
 int n,m,ans,D,cnt,p[N],tot,root;
 struct node{
     int d[],mn[],mx[],l,r,D,size,sum,v;
     int& operator [] (int x){return d[x];}
 }t[N],now;
 inline bool cmp(int x,int y){return t[x][D]<t[y][D];}
 
 #define L t[o].l
 #define R t[o].r
 #define mid (l+r>>1)
 inline void Push_up(int o){
     F(i,,){
         t[o].mn[i]=min(t[o].mn[i],min(t[L].mn[i],t[R].mn[i]));
         t[o].mx[i]=max(t[o].mx[i],max(t[L].mx[i],t[R].mx[i]));
     }
     t[o].sum=t[L].sum+t[R].sum+t[o].v;
     t[o].size=t[L].size+t[R].size+;
 }
 inline int build(int l,int r,int dir){
     D=dir;
     nth_element(p+l,p+mid,p+r+,cmp);
     int o=p[mid];
     t[o].D=dir;
     F(i,,) t[o].mn[i]=t[o].mx[i]=t[o][i];
     t[o].sum=t[o].v;
     L=l<mid ? build(l,mid-,dir^) : ;
     R=mid<r ? build(mid+,r,dir^) : ;
     Push_up(o);
     return o;
 }
 inline void dfs(int o){
     if (!o) return;
     dfs(L);
     p[++cnt]=o;
     dfs(R);
 }
 inline void rebuild(int &o){
     cnt=;
     dfs(o);
     o=build(,cnt,t[o].D);
 }
 inline void Insert(int &o,int dir){
     if (!o){
         o=++tot; t[o]=now;
         F(i,,) t[o].mn[i]=t[o].mx[i]=t[o][i];
         t[o].D=dir;
         t[o].size=;
         t[o].sum=t[o].v;
         return;
     }
     if (now[dir]<t[o][dir]){
         Insert(L,dir^);
         Push_up(o);
         if ((double)t[L].size>(double)t[o].size*0.7) rebuild(o);
     }
     else{
         Insert(R,dir^);
         Push_up(o);
         if ((double)t[R].size>(double)t[o].size*0.7) rebuild(o);
     }
 }
 int query(int o,int x1,int y1,int x2,int y2){
     if (!o) return ;
     if (t[o].mn[]>=x1 && t[o].mn[]>=y1 && t[o].mx[]<=x2 && t[o].mx[]<=y2)
         return t[o].sum;
     else{
         int ans=;
         if (t[o][]>=x1 && t[o][]<=x2 && t[o][]>=y1 && t[o][]<=y2) ans+=t[o].v;
         if (t[L].mn[]>x2 || t[L].mx[]<x1 || t[L].mn[]>y2 || t[L].mx[]<y1) ;
         else ans+=query(L,x1,y1,x2,y2);
         if (t[R].mn[]>x2 || t[R].mx[]<x1 || t[R].mn[]>y2 || t[R].mx[]<y1) ;
         else ans+=query(R,x1,y1,x2,y2);
         return ans;
     }
 }
 void print(int o){
     if (!o) return;
     printf("%d t[o].mn[0]=%d t[o].mn[1]=%d t[o].mx[0]=%d t[o].mx[1]=%d\n",o,t[o].mn[],t[o].mn[],t[o].mx[],t[o].mx[]);
     print(L);
     print(R);
 }
 int main(){
 #ifndef ONLINE_JUDGE
     freopen("4066.in","r",stdin);
     freopen("4066.out","w",stdout);
 #endif
     F(i,,) t[].mn[i]=INF,t[].mx[i]=-INF;
     t[].size=t[].sum=t[].v=;
 
     n=getint(); int cmd;
     while(scanf("%d",&cmd)!=EOF && cmd<){
         if (cmd==){
             now[]=getint()^ans,now[]=getint()^ans,now.v=getint()^ans;
             Insert(root,);
         }else{
             int x1=getint()^ans,y1=getint()^ans,x2=getint()^ans,y2=getint()^ans;
             printf("%d\n",ans=query(root,x1,y1,x2,y2));
         }
     }
     return ;
 }

4066: 简单题

Time Limit: 50 Sec  Memory Limit: 20 MB
Submit: 297  Solved: 99
[Submit][Status][Discuss]

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范围内并且解码之后数据仍合法。

样例解释见OJ2683

Source

[Submit][Status][Discuss]