HDU 4400-Mines-KDtree

题意就是给n个炸弹， 选择m个去引爆，每个炸弹的影响范围是D，这里的距离是曼哈顿距离，炸弹之间会相互引爆

问每次选择的一个炸弹后，最后引爆的炸弹个数

构建kdtree，然后每次搜最近点，加到队列bfs炸开，复杂度 构建n*logn，查询n*logn

#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <iostream>
using namespace std;
const int INF = 0x7fffffff; 
struct node
{
    int d[2], l, r,rad,id;
    int Max[2], Min[2];
} t[100000 + 10],tmp;
int ori[100000+10][3];
int vis[100000+500];
int n,m,root,cmp_d;
int k1, k2, k3, Ans;

bool cmp(node a, node b)
{
    return (a.d[cmp_d]<b.d[cmp_d]) || ((a.d[cmp_d] == b.d[cmp_d]) && (a.d[!cmp_d] < b.d[!cmp_d]));
}
void update(int p)
{
    if (t[p].l)
    {
        t[p].Max[0] = max(t[p].Max[0], t[t[p].l].Max[0]);
        t[p].Min[0] = min(t[p].Min[0], t[t[p].l].Min[0]);
        t[p].Max[1] = max(t[p].Max[1], t[t[p].l].Max[1]);
        t[p].Min[1] = min(t[p].Min[1], t[t[p].l].Min[1]);
    }
    if (t[p].r)
    {
        t[p].Max[0] = max(t[p].Max[0], t[t[p].r].Max[0]);
        t[p].Min[0] = min(t[p].Min[0], t[t[p].r].Min[0]);
        t[p].Max[1] = max(t[p].Max[1], t[t[p].r].Max[1]);
        t[p].Min[1] = min(t[p].Min[1], t[t[p].r].Min[1]);
    }
    return;
}
int build(int l, int r, int D)
{
    int mid = (l + r) / 2;
    cmp_d = D;
    nth_element(t + l + 1, t + mid + 1, t + r + 1, cmp);
    t[mid].Max[0] = t[mid].Min[0] = t[mid].d[0];
    t[mid].Max[1] = t[mid].Min[1] = t[mid].d[1];
    if (l != mid) t[mid].l = build(l, mid - 1, D ^ 1);
    if (r != mid) t[mid].r = build(mid + 1, r, D ^ 1);
    update(mid);
    return mid;
}
void insert(int now)
{
    int D = 0, p = root;
    while (1)
    {
        t[p].Max[0] = max(t[p].Max[0], t[now].Max[0]);
        t[p].Min[0] = min(t[p].Min[0], t[now].Min[0]);
        t[p].Max[1] = max(t[p].Max[1], t[now].Max[1]);
        t[p].Min[1] = min(t[p].Min[1], t[now].Min[1]);
        if (t[now].d[D] >= t[p].d[D])
        {
            if (t[p].r == 0)
            {
                t[p].r = now;
                return;
            }
            else p = t[p].r;
        }
        else
        {
            if (t[p].l == 0)
            {
                t[p].l = now;
                return;
            }
            else p = t[p].l;
        }
        D = D ^ 1;
    }
    return;
}
int ABS(int x)
{
    return x < 0? -x : x;
}
int dist(int p1, int px, int py)
{
    int dist = 0;
    if (px < t[p1].Min[0]) dist += t[p1].Min[0] - px;
    if (px > t[p1].Max[0]) dist += px - t[p1].Max[0];
    if (py < t[p1].Min[1]) dist += t[p1].Min[1] - py;
    if (py > t[p1].Max[1]) dist += py - t[p1].Max[1];
    return dist;
}
int sum;
queue<int> q;
void ask(int p)
{
    int dl, dr, d0;
    d0=ABS(t[p].d[0] - k2) + ABS(t[p].d[1] - k3);
    if(d0 <= Ans)
    {
        if(!vis[t[p].id]) q.push(t[p].id);
    }
    if(t[p].l) dl = dist(t[p].l, k2, k3);
    else dl =0x7f7f7f7f;
    if(t[p].r) dr = dist(t[p].r, k2, k3);
    else dr = 0x7f7f7f7f;
    if(dl < dr)
    {
        if(dl <= Ans) ask(t[p].l);
        if(dr <= Ans) ask(t[p].r);
    }
    else
    {
        if(dr <= Ans) ask(t[p].r);
        if(dl <= Ans) ask(t[p].l);
    }
}

void init()
{
    memset(t,0,sizeof t);
    memset(vis,0,sizeof vis);
    for (int i = 1; i <= n; i++)
        scanf("%d%d%d", &t[i].d[0], &t[i].d[1],&t[i].rad);
    for (int i = 1; i <= n; i++)
        t[i].id=i;
    for (int i = 1; i <= n; i++)
        ori[i][0]=t[i].d[0], ori[i][1]=t[i].d[1] , ori[i][2]=t[i].rad;
    root = build(1, n, 0);
    scanf("%d",&m);

}
void work()
{
    for (int i = 1; i <= m ; i++)
    {
        int x;
        scanf("%d",&x);

        sum=0;
        q.push(x);
        while(!q.empty())
        {
            int tp=q.front();
            q.pop();
            if (!vis[tp])
            {
                vis[tp]=1;
                sum++;
                Ans = ori[tp][2];
                k2=ori[tp][0];
                k3=ori[tp][1];
                ask(root);
            }
        }
        printf("%d\n", sum);
    }
}

int main()
{
    int cnt=1;
    while(   scanf("%d", &n )!=EOF&&n)
    {
        printf("Case #%d:\n",cnt++);
        init();
        work();
    }
    return 0;
}