bzoj1941 hdu5992

看了青岛赛区的题简单学了一下kd，感觉这东西还是挺厉害的

一般kd树找最近点对最坏是O(n)，但是随机情况下跑得还是很快的

kd树是一棵BST，但是每一层的关键字不同

一般写法是按照每一维轮流来，这一维小的放左子树，大的放右边的

每个节点再维护这节点所管辖的节点每一维的范围，这样基本就能做题了

kdtree一般是静态直接建好的，插入可以套一个替罪羊树重构做到logn，但是据说慢

那么怎么查询最近点呢

每到一个节点，比较通过这节点所管辖点的每一维的范围，估计出可能最小的距离

优先访问估值优的子树

可以看到查询几乎就是个搜索+剪枝，所以最坏是O(n)，最远点类似

这样bzoj1941就解了

#include<bits/stdc++.h>

using namespace std;
const int inf=1e9+7;
int key,dmx,dmi,root,n,x[500010],y[500010];

struct node
{
    int son[2],mi[2],mx[2],d[2];
    friend bool operator <(node a,node b)
    {
        return a.d[key]<b.d[key];
    }
    friend int dis(node a,node b)
    {
        return abs(a.d[1]-b.d[1])+abs(a.d[0]-b.d[0]);
    }
} po;

struct kdtree
{
    node a[500010];
    void init()
    {
        a[0].son[0]=a[0].son[1]=0;
        for (int i=0; i<2; i++)
        {
            a[0].mi[i]=inf;
            a[0].mx[i]=-inf;
        }
    }
    void update(int x)
    {
        int l=a[x].son[0],r=a[x].son[1];
        for (int i=0; i<2; i++)
        {
            a[x].mi[i]=min(a[x].d[i],min(a[l].mi[i],a[r].mi[i]));
            a[x].mx[i]=max(a[x].d[i],max(a[l].mx[i],a[r].mx[i]));
        }
    }
    int build(int l,int r,int cur)
    {
        if (l>r) return 0;
        int m=(l+r)>>1;
        key=cur; nth_element(a+l,a+m,a+r+1);
        a[m].son[0]=build(l,m-1,cur^1);
        a[m].son[1]=build(m+1,r,cur^1);
        update(m);
        return m;
    }
    int getmi(int x)
    {
        int s=0;
        for (int i=0;i<2;i++)
            s+=max(po.d[i]-a[x].mx[i],0)+max(a[x].mi[i]-po.d[i],0);
        return s;
    }
    int getmx(int x)
    {
        int s=0;
        for (int i=0;i<2;i++)
            s+=max(abs(po.d[i]-a[x].mi[i]),abs(po.d[i]-a[x].mx[i]));
        return s;
    }
    void askmx(int q)
    {
        dmx=max(dmx,dis(a[q],po));
        int l=a[q].son[0],r=a[q].son[1],dl=-inf,dr=-inf;
        if (l) dl=getmx(l);
        if (r) dr=getmx(r);
        if (dl>dr)
        {
            if (dl>dmx) askmx(l);
            if (dr>dmx) askmx(r);
        }
        else {
            if (dr>dmx) askmx(r);
            if (dl>dmx) askmx(l);
        }
    }
    void askmi(int q)
    {
        int dd=dis(a[q],po); if (dd) dmi=min(dmi,dd);
        int l=a[q].son[0],r=a[q].son[1],dl=inf,dr=inf;
        if (l) dl=getmi(l);
        if (r) dr=getmi(r);
        if (dl<dr)
        {
            if (dl<dmi) askmi(l);
            if (dr<dmi) askmi(r);
        }
        else {
            if (dr<dmi) askmi(r);
            if (dl<dmi) askmi(l);
        }
    }
} kd;

int main()
{
    kd.init();
    scanf("%d",&n);
    for (int i=1; i<=n; i++)
    {
        scanf("%d%d",&x[i],&y[i]);
        kd.a[i].d[0]=x[i];
        kd.a[i].d[1]=y[i];
    }
    root=kd.build(1,n,0); int ans=inf;
    for (int i=1;i<=n;i++)
    {
        dmx=-inf,dmi=inf;
        po.d[0]=x[i],po.d[1]=y[i];
        kd.askmx(root); kd.askmi(root);
        ans=min(ans,dmx-dmi);
    }
    printf("%d\n",ans);
}

 

hdu5992要加一维价格剪枝，如果这个节点所辖节点的最小价格都比询问大就不访问了

#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int inf=1e9+7;
int key,root,n,m;
ll len;
ll sqr(ll x)
{
    return x*x;
}

struct node
{
    int d[3],mi[3],mx[3],son[2],id;
    friend bool operator <(node a,node b)
    {
        return a.d[key]<b.d[key];
    }
    friend ll dis(node a,node b)
    {
        return sqr(a.d[1]-b.d[1])+sqr(a.d[0]-b.d[0]);
    }
} po,ans;

struct kdtree
{
    node a[200010];
    void init()
    {
        a[0].son[0]=a[0].son[1]=0;
        for (int i=0; i<3; i++)
        {
            a[0].mi[i]=inf;
            a[0].mx[i]=-inf;
        }
    }
    void update(int x)
    {
        int l=a[x].son[0],r=a[x].son[1];
        for (int i=0; i<3; i++)
        {
            a[x].mi[i]=min(a[x].d[i],min(a[l].mi[i],a[r].mi[i]));
            a[x].mx[i]=max(a[x].d[i],max(a[l].mx[i],a[r].mx[i]));
        }
    }
    int build(int l,int r,int cur)
    {
        if (l>r) return 0;
        int m=(l+r)>>1;
        key=cur; nth_element(a+l,a+m,a+r+1);
        a[m].son[0]=build(l,m-1,cur^1);
        a[m].son[1]=build(m+1,r,cur^1);
        update(m);
        return m;
    }
    void check(int q)
    {
        if (a[q].d[2]>po.d[2]) return;
        ll l=dis(a[q],po);
        if ((len>l)||((len==l)&&ans.id>a[q].id))
        {
            ans=a[q];
            len=l;
        }
    }
    ll get(int q)
    {
        if (!q||a[q].mi[2]>po.d[2]) return 1e18+5;
        ll s=0;
        for (int i=0; i<2; i++)
        {
            if (po.d[i]<a[q].mi[i]) s+=sqr(po.d[i]-a[q].mi[i]);
            if (po.d[i]>a[q].mx[i]) s+=sqr(po.d[i]-a[q].mx[i]);
        }
        return s;
    }
    void ask(int q)
    {
        if (a[q].mi[2]>po.d[2]) return;
        check(q);
        int l=a[q].son[0],r=a[q].son[1];
        ll dl=get(l),dr=get(r);
        if (dl<dr)
        {
            if (dl<=len) ask(l);
            if (dr<=len) ask(r);
        }
        else {
            if (dr<=len) ask(r);
            if (dl<=len) ask(l);
        }
    }
} kd;

int main()
{
    kd.init();
    int cas;
    scanf("%d",&cas);
    while (cas--)
    {
        scanf("%d%d",&n,&m);
        for (int i=1; i<=n; i++)
        {
            int x,y,c;
            scanf("%d%d%d",&x,&y,&c);
            kd.a[i].d[0]=x; kd.a[i].d[1]=y; kd.a[i].d[2]=c;
            kd.a[i].id=i;
        }
        root=kd.build(1,n,0);
        for (int i=1; i<=m; i++)
        {
            scanf("%d%d%d",&po.d[0],&po.d[1],&po.d[2]);
            len=1e18; kd.ask(root);
            printf("%d %d %d\n",ans.d[0],ans.d[1],ans.d[2]);
        }
    }
}