【科技】KD-tree随想

大概就是个复杂度对的暴力做法，在你不想写二维线段树等的时候优秀的替代品。

优点：思路简单，代码好写。

他大概有两种用法（虽然差不多）。

在平面坐标系中干一些事情：

例如最常规的平面最近最远点，不管是欧几里得距离还是曼哈顿距离，本质上都是一样的。

利用不同维度的尽量平均的分割，再在询问时剪枝。

这里给出一个曼哈顿距离上的最近最远距离的版本，可供参考：

namespace KD {
    int Rt, lc[N], rc[N], u[N], d[N], l[N], r[N];
    inline void Merge(int x, int y) {
        u[x] = std::max(u[x], u[y]);
        d[x] = std::min(d[x], d[y]);
        l[x] = std::min(l[x], l[y]);
        r[x] = std::max(r[x], r[y]);
    }
    inline void Up(int t) {
        l[t] = r[t] = p[t].v[0];
        u[t] = d[t] = p[t].v[1];
        if (lc[t]) Merge(t, lc[t]);
        if (rc[t]) Merge(t, rc[t]);
    }
    int Build(int l, int r, int dep) {
        if (l >= r) {
            if (l == r) Up(l);
            return (l == r)? (l) : (0);
        }
        Mt = dep & 1; int md = (l + r) >> 1;
        std::nth_element(p + l, p + md, p + 1 + r);
        lc[md] = Build(l, md - 1, dep + 1);
        rc[md] = Build(md + 1, r, dep + 1);
        Up(md); return md;
    }
    inline int In_mi(int t) {
        int re = 0;
        re += std::max(qi.v[0] - r[t], 0);
        re += std::max(l[t] - qi.v[0], 0);
        re += std::max(qi.v[1] - u[t], 0);
        re += std::max(d[t] - qi.v[1], 0);
        return re;
    }
    inline int In_ma(int t) {
        int re = 0;
        re += std::max(std::abs(qi.v[0] - r[t]), std::abs(qi.v[0] - l[t]));
        re += std::max(std::abs(qi.v[1] - u[t]), std::abs(qi.v[1] - d[t]));
        return re;
    }
    void Query_mi(int t, int dep) {
        if (!t) return; Mt = dep & 1;
        if (qi != p[t]) ani = std::min(ani, Dis(qi, p[t]));
        int dl = (lc[t])? (In_mi(lc[t])) : (INF);
        int dr = (rc[t])? (In_mi(rc[t])) : (INF);
        if (dl < dr) {
            if (ani > dl) Query_mi(lc[t], dep + 1);
            if (ani > dr) Query_mi(rc[t], dep + 1);
        } else {
            if (ani > dr) Query_mi(rc[t], dep + 1);
            if (ani > dl) Query_mi(lc[t], dep + 1);
        }
    }
    void Query_ma(int t, int dep) {
        if (!t) return; Mt = dep & 1;
        ana = std::max(ana, Dis(qi, p[t]));
        int dl = (lc[t])? (In_ma(lc[t])) : (0);
        int dr = (rc[t])? (In_ma(rc[t])) : (0);
        if (dl > dr) {
            if (ana < dl) Query_ma(lc[t], dep + 1);
            if (ana < dr) Query_ma(rc[t], dep + 1);
        } else {
            if (ana < dr) Query_ma(rc[t], dep + 1);
            if (ana < dl) Query_ma(lc[t], dep + 1);
        }
    }
}

通常带有表示点的结构体：

struct No {
    int v[2];
    inline void Read() {
        scanf("%d%d", &v[0], &v[1]);
    }
    inline friend bool operator < (No a, No b) {
        return a.v[Mt] < b.v[Mt];
    }
} p[N], qi;

（注：$qi$表示当前询问点，$Mt$表示当前分割的维度）

当然还有某些问题要求第$k$远点，只要每次查到一个点就扔到堆里去，时时维护最远的$k$个就好了，因为KD-tree剪掉了很多不必要的点，所以可以认为扔到堆里的元素并不多。

或者说动态的问题需要动态开点，开多了就可能导致树不平衡，隔一会重构就好了。

当然KD-tree在坐标系上最大的优越之处在于乱搞，旋转一下坐标系之后什么都拦不住KD-tree啦。

比如说APIO 2018的选圈圈。。。把圆用矩形框起来，每次暴力找就好了。

#include <cstdio>
#include <algorithm>

const int N = 300005;
const double Alpha = 1.926, EPS = 1e-4;

int n, Mt, ans[N];

struct No {
    double v[2], r; int id;
    inline void Read(double x = 0, double y = 0) {
        scanf("%lf%lf%lf", &x, &y, &r);
        v[0] = x * cos(Alpha) + y * sin(Alpha);
        v[1] = y * cos(Alpha) - x * sin(Alpha);
    }
    inline friend bool operator < (No a, No b) {
        return a.v[Mt] < b.v[Mt];
    }
} pp[N], p[N], qi;

inline bool cmp_r(No a, No b) {
    return (a.r == b.r)? (a.id < b.id) : (a.r > b.r);
}
inline double Sqr(double x) {
    return x * x;
}

namespace KD {
    int Rt, lc[N], rc[N];
    double l[N], r[N], d[N], u[N];
    inline void Merge(int x, int y) {
        l[x] = std::min(l[x], l[y]);
        r[x] = std::max(r[x], r[y]);
        d[x] = std::min(d[x], d[y]);
        u[x] = std::max(u[x], u[y]);
    }
    inline void Up(int t) {
        l[t] = p[t].v[0] - p[t].r;
        r[t] = p[t].v[0] + p[t].r;
        d[t] = p[t].v[1] - p[t].r;
        u[t] = p[t].v[1] + p[t].r;
        if (lc[t]) Merge(t, lc[t]);
        if (rc[t]) Merge(t, rc[t]);
    }
    int Build(int l, int r, int dep) {
        if (l >= r) return (l == r)? (Up(l), l) : (0);
        Mt = dep & 1; int md = (l + r) >> 1;
        std::nth_element(p + l, p + md, p + 1 + r);
        lc[md] = Build(l, md - 1, dep + 1);
        rc[md] = Build(md + 1, r, dep + 1);
        Up(md); return md;
    }
    inline int Out(int t) {
        int re1 = r[t] < qi.v[0] - qi.r - EPS || l[t] > qi.v[0] + qi.r + EPS;
        int re2 = u[t] < qi.v[1] - qi.r - EPS || d[t] > qi.v[1] + qi.r + EPS;
        return re1 || re2;
    }
    inline int Check(int t) {
        return Sqr(p[t].r + qi.r) + EPS >= Sqr(p[t].v[0] - qi.v[0]) + Sqr(p[t].v[1] - qi.v[1]);
    }
    void Query(int t) {
        if (!t || Out(t)) return;
        if (!ans[p[t].id] && Check(t)) ans[p[t].id] = qi.id;
        if (lc[t]) Query(lc[t]);
        if (rc[t]) Query(rc[t]);
    }
}

int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) {
        p[i].Read();
        p[i].id = i;
        pp[i] = p[i];
    }
    std::sort(pp + 1, pp + 1 + n, cmp_r);
    KD::Rt = KD::Build(1, n, 0);
    
    for (int i = 1; i <= n; ++i) {
        if (!ans[pp[i].id]) {
            ans[pp[i].id] = pp[i].id;
            qi = pp[i];
            KD::Query(KD::Rt);
        }
    }
    for (int i = 1; i <= n; ++i) {
        printf("%d ", ans[i]);
    }
    
    return 0;
}

二维线段树的替代品：

由于KD-tree本身就和值域没有什么关系，涉及到二维数点、矩形修改、矩形询问等问题可以比较方便的做，只要每个点维护一个矩形，然后大致就和线段树差不多了。

其实很多问题都能转化为二维平面甚至多维上的数点问题，有些问题离线后把时间也算成一维也是一个常用套路，KD-tree在这方面处理能力较强，适用范围较广。

要注意KD-tree上每一个点都是一个真实的点，修改时不要忘记更新它本身。

可能左右两个子节点表示的矩形存在相交，有时候自顶向下不一定好。