题意就是给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;
}