bzoj4066 简单题

(http://www.elijahqi.win/2018/01/12/bzoj4066-%E7%AE%80%E5%8D%95%E9%A2%98)
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

新加数据一组，但未重测—-2015.05.24

Source

By wjy1998

自己的一个做法 代码真的非常丑陋 跑了48s卡时跑过 因为蒟蒻我的做法实在太暴力的qwq

针对每个矩形我去容斥一下 相当于是跑四回 然后加加减减得到答案 query表示加法 query1表示减法 加了些剪枝 比如横纵坐标有一维是0及一下了 那我就干脆就不去kd-tree上跑了 因为一定是0 此外在kd-tree上的操作也可谓是十分暴力 如果这个平面完全被我的查询平面覆盖了 就底下再划分的平面我就不做了 直接取答案 或者是 只要我查询的范围的一部分在我这个节点的中 那我就递归下去做那个节点 因为我存在一直插入 导致无法平衡的可能那我就没10000就暴力重构一下我的kd-tree来保证我的复杂度 类似替罪羊树？
注意维护每个子树权值和的时候 我需要把我这个节点的权值也加入 然后重新统计下 答案因为如果我在建树或者直接插入的时候就去改动这个值是会有问题的

#include<cmath>
#include<cstdio>
#include<algorithm>
#define inf 0x3f3f3f3f
#define N 220000
#define ll long long
using namespace std;
inline char gc(){
    static char now[1<<16],*S,*T;
    if(T==S){T=(S=now)+fread(now,1,1<<16,stdin);if (T==S) return EOF;}
    return *S++;
}
inline int read(){
    int x=0,f=1;char ch=gc();
    while(ch<'0'||ch>'9') {if (ch=='-') f=-1;ch=gc();}
    while(ch<='9'&&ch>='0'){x=x*10+ch-'0';ch=gc();}
    return x*f;
}
struct node{
    int left,right,x,y,minx,miny,maxx,maxy;ll sum,v;
}tree[N];
int D,n,m,op,num,root;ll ans;
struct node1{
    int x,y;ll v;
    friend bool operator<(node1 a,node1 b){
        if (!D) return a.x<b.x;else return a.y<b.y;
    }
}point[N],P;
inline void update(int x){
    int l=tree[x].left,r=tree[x].right;
    tree[x].sum=tree[x].v+tree[l].sum+tree[r].sum;
    tree[x].minx=min(tree[x].minx,min(tree[l].minx,tree[r].minx));
    tree[x].miny=min(tree[x].miny,min(tree[l].miny,tree[r].miny));
    tree[x].maxx=max(tree[x].maxx,max(tree[l].maxx,tree[r].maxx));
    tree[x].maxy=max(tree[x].maxy,max(tree[l].maxy,tree[r].maxy));
}
inline void build(int &x,int l,int r,int dim){
    D=dim;x=++num;int mid=l+r>>1;nth_element(point+l,point+mid,point+r+1);tree[x].left=tree[x].right=0;
    tree[x].x=point[mid].x;tree[x].y=point[mid].y;tree[x].v=tree[x].sum=point[mid].v;
    tree[x].minx=tree[x].maxx=point[mid].x;tree[x].miny=tree[x].maxy=point[mid].y;
    if (l<mid) build(tree[x].left,l,mid-1,dim^1);
    if (r>mid) build(tree[x].right,mid+1,r,dim^1);update(x);
}
inline void init(int &x){
    x=++num;tree[x].x=P.x;tree[x].y=P.y;tree[x].sum=tree[x].v=P.v;tree[x].left=tree[x].right=0;
    tree[x].minx=tree[x].maxx=P.x;tree[x].miny=tree[x].maxy=P.y;
}
inline void insert1(int x,int dim){
    if (P.x==tree[x].x&&P.y==tree[x].y) tree[x].sum+=P.v,tree[x].v+=P.v;else
    if (!dim){
        if (P.x<tree[x].x){
            if (tree[x].left) insert1(tree[x].left,dim^1);else init(tree[x].left);
        }else{
            if(tree[x].right) insert1(tree[x].right,dim^1);else init(tree[x].right);
        }
    }else{
        if (P.y<tree[x].y){
            if (tree[x].left) insert1(tree[x].left,dim^1);else init(tree[x].left);
        }else{
            if (tree[x].right) insert1(tree[x].right,dim^1);else init(tree[x].right);
        }
    }update(x);
}
inline bool judge1(int x){
    return (tree[x].maxx<=P.x)&&(tree[x].maxy<=P.y);
}
inline bool judge2(int x){
    return (tree[x].minx<=P.x)&&(tree[x].miny<=P.y);
}
inline void query(int x,int dim){
    if (tree[x].x<=P.x&&tree[x].y<=P.y) ans+=tree[x].v;
    int l=tree[x].left,r=tree[x].right;
    if (tree[x].left) {if (judge1(tree[x].left)) ans+=tree[l].sum;else if (judge2(tree[x].left)) query(tree[x].left,dim^1);}
    if (tree[x].right) {if (judge1(tree[x].right)) ans+=tree[r].sum;else if (judge2(tree[x].right)) query(tree[x].right,dim^1);}
}
inline void query1(int x,int dim){
    if (tree[x].x<=P.x&&tree[x].y<=P.y) ans-=tree[x].v;
    int l=tree[x].left,r=tree[x].right;
    if (tree[x].left) {if (judge1(tree[x].left)) ans-=tree[l].sum;else if (judge2(tree[x].left)) query1(tree[x].left,dim^1);}
    if (tree[x].right) {if (judge1(tree[x].right)) ans-=tree[r].sum;else if (judge2(tree[x].right)) query1(tree[x].right,dim^1);}
}
int main(){
    freopen("bzoj4066.in","r",stdin);
    n=read();n=0;ll last_ans=0;int nm=0;tree[0].minx=tree[0].miny=inf;
    while(1){
        op=read();if (op==3) break;
        if (op==1){
            P.x=read()^last_ans;P.y=read()^last_ans;P.v=read()^last_ans;
            ++n;if (n==10000) {
                nm=num;for (int i=1;i<=nm;++i) point[i].x=tree[i].x,point[i].y=tree[i].y,point[i].v=tree[i].v;n=0,num=0;
                build(root,1,nm,0);
            }
            if (!root) tree[++root].x=P.x,tree[root].y=P.y,num=1,
            tree[root].sum=tree[root].v=P.v,tree[root].minx=tree[root].maxx=P.x,tree[root].miny=tree[root].maxy=P.y;
            else insert1(root,0);continue;
        }else{
            ans=0;int x1=read()^last_ans,y1=read()^last_ans,x2=read()^last_ans,y2=read()^last_ans;
            if (x1>x2) swap(x1,x2),swap(y1,y2);
            P.x=x2;P.y=y2;query(root,0);P.x=x1-1;P.y=y2;if (P.x>=0)query1(root,0);
            P.x=x2;P.y=y1-1;if(P.y>0) query1(root,0);P.x=x1-1;P.y=y1-1;if (P.x>0&&P.y>0)query(root,0);
            last_ans=ans;printf("%lld\n",ans);
        }
    }
    return 0;
}

在23.15的时候因为改不对自己的代码 下定决心向巨佬icefox学习 代码短小精悍 同时也适用多维orz

zhx 巨佬在kd-tree上跑的时候估价函数 是非常巧妙的十分类似线段树 因为我们可以看出对于做到的每个节点代表的平面 分完全包含 完全不包含 包含我这个节点 都可以直接处理 然后对于有相交的部分同样也是递归下去搞一下

#include<cstdio>
#include<algorithm>
#define ll long long
#define N 220000
#define inf 0x3f3f3f3f
using namespace std;
inline char gc(){
    static char now[1<<16],*S,*T;
    if (T==S){T=(S=now)+fread(now,1,1<<16,stdin);if (T==S) return EOF;}
    return *S++;
}
inline int read(){
    int x=0;char ch=gc();
    while(ch<'0'||ch>'9') ch=gc();
    while(ch<='9'&&ch>='0') x=x*10+ch-'0',ch=gc();
    return x; 
}
int n,D,num,root;ll ans;
struct node1{
    int d[2],v;
    int& operator[](int x){return d[x];}
    friend bool operator<(node1 a,node1 b){return a[D]<b[D];}
}point[N];
struct node{
    node1 x;int min[2],max[2],left,right;ll sum;
}tree[N];
inline void update(int x){
    int l=tree[x].left,r=tree[x].right;
    tree[x].sum=tree[l].sum+tree[r].sum+tree[x].x.v;
    for (int i=0;i<2;++i) tree[x].min[i]=min(tree[x].min[i],min(tree[l].min[i],tree[r].min[i]));
    for (int i=0;i<2;++i) tree[x].max[i]=max(tree[x].max[i],max(tree[l].max[i],tree[r].max[i]));
}
inline void insert1(int &x,int dim){
    if (!x){
        x=++num;tree[x].x=point[n];tree[x].left=tree[x].right=0;tree[x].sum=point[n].v;
        for (int i=0;i<2;++i) tree[x].min[i]=point[n][i],tree[x].max[i]=point[n][i];return;
    }
    if(point[n][dim]<=tree[x].x[dim]) insert1(tree[x].left,dim^1);else insert1(tree[x].right,dim^1);update(x);
}
inline void build(int &x,int l,int r,int dim){
    x=++num;D=dim;int mid=l+r>>1;nth_element(point+l,point+mid,point+r+1);tree[x].left=tree[x].right=0;
    tree[x].x=point[mid];for (int i=0;i<2;++i) tree[x].min[i]=tree[x].max[i]=point[mid][i];tree[x].sum=point[mid].v;
    if (l<mid) build(tree[x].left,l,mid-1,dim^1);
    if (r>mid) build(tree[x].right,mid+1,r,dim^1);update(x);
}int x1,y1,x2,y2;
inline bool judge(int x){
    return tree[x].min[0]>=x1&&tree[x].max[0]<=x2&&tree[x].min[1]>=y1&&tree[x].max[1]<=y2;
}
inline bool judge1(int x){
    return tree[x].min[0]>x2||tree[x].min[1]>y2||tree[x].max[0]<x1||tree[x].max[1]<y1;
}
inline bool judge2(int x){
    return x1<=tree[x].x[0]&&tree[x].x[0]<=x2&&y1<=tree[x].x[1]&&tree[x].x[1]<=y2;
}
inline void query(int x,int dim){
    if (!x) return;if (judge(x)) {ans+=tree[x].sum;return;}
    if (judge1(x)) return;if(judge2(x)) ans+=tree[x].x.v;
    query(tree[x].left,dim^1);query(tree[x].right,dim^1);
}
int main(){
    freopen("bzoj4066.in","r",stdin);
    n=read();n=0;tree[0].min[0]=tree[0].min[1]=inf;ll last_ans=0;
    while(1){
        int op=read();if (op==3) return 0;
        if (op==1){
            point[++n][0]=read()^last_ans;point[n][1]=read()^last_ans;point[n].v=read()^last_ans;
            if (n%10000==0) num=0,build(root,1,n,0);else insert1(root,0);
        }else{
            x1=read()^last_ans;y1=read()^last_ans;x2=read()^last_ans;y2=read()^last_ans;
            ans=0;query(root,0);printf("%lld\n",ans);last_ans=ans;
        }
    }
    return 0;
}