BZOJ4170: 极光

将每个位置的位置定为x，graze值定为y
那么任意位置上出现过的任意数值就对应上了平面上的若干个点
每次询问和一个点的哈密顿距离 <= x的点的个数
将哈密顿距离转为切比雪夫距离$(x,y)->(x+y,x-y)$
和一个点切比雪夫距离 <= x的点对应平面上一个矩形
那么询问就变成了询问平面上一个矩形内的点的个数
用KD-tree或cdq都是兹瓷的

code：

#include<set>
#include<map>
#include<deque>
#include<queue>
#include<stack>
#include<cmath>
#include<ctime>
#include<bitset>
#include<string>
#include<vector>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<climits>
#include<complex>
#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;

inline void up(int &x,const int &y){if(x<y)x=y;}
inline void down(int &x,const int &y){if(x>y)x=y;}
inline void read(int &x)
{
    char c; int f=1;
    while(!((c=getchar())>='0'&&c<='9')) if(c=='-') f*=-1;
    x=c-'0';
    while((c=getchar())>='0'&&c<='9') (x*=10)+=c-'0';
    x*=f;
}
const int maxn = 161000;
const int maxm = 101000;
const int maxd = 2;

struct KD_tree
{
    int i,fa,lc,rc,pos[maxd],u[maxd],d[maxd],c,s;
}kd[maxn]; int N,root;
int id[maxn];
int cmp_d; inline bool cmp(KD_tree x,KD_tree y){return x.pos[cmp_d]<y.pos[cmp_d];}

inline void push_up(const int x)
{
    int lc=kd[x].lc,rc=kd[x].rc;
    if(lc) 
    {
        for(int i=0;i<maxd;i++) 
            up(kd[x].u[i],kd[lc].u[i]),
            down(kd[x].d[i],kd[lc].d[i]);
        kd[x].c+=kd[lc].c;
    }
    if(rc)
    {
        for(int i=0;i<maxd;i++)
            up(kd[x].u[i],kd[rc].u[i]),
            down(kd[x].d[i],kd[rc].d[i]);
        kd[x].c+=kd[rc].c;
    }
}
int build_(const int l,const int r,const int ff,int D)
{
    int x=(l+r)>>1;
    cmp_d=D; std::nth_element(kd+l,kd+x,kd+r+1,cmp);
    for(int i=0;i<maxd;i++) kd[x].u[i]=kd[x].d[i]=kd[x].pos[i];
    kd[x].c=kd[x].s; kd[x].fa=ff;

    if(l!=x) kd[x].lc=build_(l,x-1,x,!D);
    if(x!=r) kd[x].rc=build_(x+1,r,x,!D);
    push_up(x);
    return x;
}
void upd(int x)
{
    kd[x].c++;
    while(x=kd[x].fa) kd[x].c++;
}
int u[maxd],d[maxd];
int query(const int x)
{
    for(int i=0;i<maxd;i++)
        if(kd[x].u[i]<d[i]||kd[x].d[i]>u[i]) return 0;
    if(d[0]<=kd[x].d[0]&&kd[x].u[0]<=u[0]&&d[1]<=kd[x].d[1]&&kd[x].u[1]<=u[1]) return kd[x].c;
    int re=0;
    if(d[0]<=kd[x].pos[0]&&kd[x].pos[0]<=u[0]&&d[1]<=kd[x].pos[1]&&kd[x].pos[1]<=u[1]) re+=kd[x].s;
    return re+query(kd[x].lc)+query(kd[x].rc);
}

struct point{int x,y;};
inline bool operator <(point x,point y){return x.x==y.x?x.y<y.y:x.x<y.x;}
map<point,int>h;

struct node
{
    int x,y,k,q;
    node(){}
    node(const int _x,const int _y,const int _k,const int _q){x=_x;y=_y;k=_k;q=_q;}
}q[maxm];
int n,m;
int v[maxn];

int main()
{
    read(n); read(m);
    for(int i=1;i<=n;i++)
    {
        int x; read(x); v[i]=x;
        point tmp; tmp.x=i+x,tmp.y=i-x;
        if(h.count(tmp)>0) kd[h[tmp]].s++;
        else
        {
            kd[h[tmp]=++N].s=1;
            kd[N].pos[0]=tmp.x,kd[N].pos[1]=tmp.y;
            kd[N].i=N;
        }
    }
    char str[10];
    for(int i=1;i<=m;i++)
    {
        scanf("%s",str);
        int x,y; read(x); read(y);
        if(str[0]=='M')
        {
            point tmp; tmp.x=x+y,tmp.y=x-y;
            q[i]=node(tmp.x,tmp.y,0,0);
            if(h.count(tmp)) q[i].k=h[tmp];
            else
            {
                kd[h[tmp]=q[i].k=++N].s=0;
                kd[N].pos[0]=tmp.x,kd[N].pos[1]=tmp.y;
                kd[N].i=N;
            }
            v[x]=y;
        }
        else q[i]=node(x+v[x],x-v[x],y,1);
    }
    root=build_(1,N,0,0);
    for(int i=1;i<=N;i++) id[kd[i].i]=i;
    for(int i=1;i<=m;i++)
    {
        if(q[i].q==0)
        {
            q[i].k=id[q[i].k];
            kd[q[i].k].s++;
            upd(q[i].k);
        }
        else
        {
            d[0]=q[i].x-q[i].k,u[0]=q[i].x+q[i].k;
            d[1]=q[i].y-q[i].k,u[1]=q[i].y+q[i].k;
            point tmp; tmp.x=q[i].x,tmp.y=q[i].y;
            printf("%d\n",query(root));
        }
    }

    return 0;
}