Can of Worms 【迭代/线段树】

题意：一条直线上有n个炸弹，给出每个炸弹的爆炸半径，可以引爆另一个炸弹爆炸。问：每个炸弹爆炸后，最多有几个炸弹一起爆炸？

迭代，用线段树更新。

 #include <cstdio>
 #include <algorithm>
 #include <iostream>
 #define ll long long
 #define lson l, m, rt<<1
 #define rson m+1, r, rt<<1|1
 #define X first
 #define Y second
 #define mp make_pair
 #define pii pair<int, int>
 #define gg puts("gg");
 using namespace std;
 const int N = 1e5+;
 struct p{
     int n, pos, ra;
     p(){}
     p(int pos, int ra):pos(pos), ra(ra){}
 };
 bool cmppos(p A, p B){
     return A.pos < B.pos;
 }

 p pp[N];
 //after sort
 int pos[N];
 int lpos[N], rpos[N], now;

 struct Node{
     int l, r;
     Node(){}
     Node(int l, int r):l(l), r(r){}
 };
 Node T[N<<];
 void pushup(int rt){
     T[rt].l = min(T[rt<<].l, T[rt<<|].l);
     T[rt].r = max(T[rt<<].r, T[rt<<|].r);
 }
 void gao(Node& x, Node y){
     if(x.l > y.l) x.l = y.l;
     if(x.r < y.r) x.r = y.r;
 }
 void update(int x, Node y, int l, int r, int rt){
     if(x == l&&x == r){
         T[rt] = y;
         return ;
     }
     int m = l+r >> ;
     if(x <= m) update(x, y, lson);
     else update(x, y, rson);
     pushup(rt);
 }
 void build(int l, int r, int rt){
     if(l == r){
         T[rt].l = lpos[now];
         T[rt].r = rpos[now];
         now++;
         return ;
     }
     int m = l+r >> ;
     build(lson);
     build(rson);
     pushup(rt);
 }
 void query(Node& ans, int L, int R, int l, int r, int rt){
     if(L <= l&& r <= R){
         gao(ans, T[rt]);
         return ;
     }
     int m = l+r >> ;
     if(L <= m) query(ans, L, R, lson);
     if(m < R) query(ans, L, R, rson);
 }
 int ans[N];
 void debug(int i){
     printf("%d: lpos:%d, rpos:%d\n", i, lpos[i], rpos[i]);
 }

 int main(){
     int n;
     while(scanf("%d", &n), n){
         for(int i = ; i <= n; i++){
             pp[i].n = i;
             scanf("%d%d", &pp[i].pos, &pp[i].ra);
             pos[i] = pp[i].pos;
         }
         sort(pos+, pos+n+);
         sort(pp+, pp+n+, cmppos);

         for(int i = ; i <= n; i++)
             lpos[i] = pp[i].pos-pp[i].ra, rpos[i] = pp[i].pos+pp[i].ra;

         now = ;
         build(, n, );

         bool tag = true;
         while(tag){
             tag = false;
             for(int i = ; i <= n; i++){
                 int lcan = lower_bound(pos+, pos+n+, lpos[i])-pos, rcan = upper_bound(pos+, pos+n+, rpos[i])-pos-;
                 ans[ pp[i].n ] = rcan-lcan+;
                 Node ret = Node(2e9, -2e9);
                 query(ret, lcan, rcan, , n, );
                 if(lpos[i] > ret.l||rpos[i] < ret.r) {
                     tag = true;
                     if(lpos[i] > ret.l) lpos[i] = ret.l;
                     if(rpos[i] < ret.r) rpos[i] = ret.r;
                     update(i, ret, , n, );
                 }
             }
         }
         for(int i = ; i <= n; i++)
             printf("%d%c", ans[i], " \n"[i == n]);
     }
     return ;
 }