hdu-4288 Coder---线段树+离线处理&离散化

题目链接：

http://acm.hdu.edu.cn/showproblem.php?pid=4288

题目大意：

维护一个有序数列{An}，有三种操作：

1、添加一个元素。

2、删除一个元素。

3、求数列中下标%5 = 3的值的和

解题思路：

线段树不支持动态的添加，删除操作，所以本题用了离线处理，将所有数字事先离散化，给每个数字存一个位子，然后处理。

先离线把要用到的数离散化，去重并且排序，这样做添加或删除操作的时候就可以用二分找出下表并在线段树内修改，由于是单点更新，就不用”向下传递“了。

其实操作和单点更新一样，只是要用一个数组sum[5]记录对应区间内mod5的5种情况的和。所以当添加或删除一个数时都是在sum[1]这里增删，可以想想区间[2,2]是不是只有一个数，那么这个数的下标是1，mod5=1,所以在sum[1]处处理，更新父节点的时候要注意，父亲的左区间的下标与左儿子的下标mod5的情况完全相同，而父亲的右区间和右儿子的下标在左儿子的个数前提上mod5，所以cnt代表区间内有效数的个数。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define MID(l, r) (l + (r - l) / 2)
 #define lson(o) (o * 2)
 #define rson(o) (o * 2 + 1)
 using namespace std;
 typedef long long ll;
 const int INF = 1e9 +;
 const int maxn = 1e6 + ;
 int  h, w, n;
 struct node
 {
     int l, r, tot;//tot表示节点个数
     ll sum[];
 }tree[maxn];
 void build(int o, int l, int r)
 {
     tree[o].l = l, tree[o].r = r;
     tree[o].tot = ;
     memset(tree[o].sum, , sizeof(tree[o].sum));
     if(l == r)
     {
         return;
     }
     int m = MID(l ,r), lc = lson(o), rc = rson(o);
     build(lc, l, m);
     build(rc, m + , r);
 }
 //a[p] += v * x
 //v表示符号，为1表示add 为-1表示del
 int p, v, x;
 void update(int o)
 {
     if(tree[o].l == tree[o].r)
     {
         tree[o].sum[] += v * x;
         tree[o].tot += v;
         return ;
     }
     int lc = lson(o), rc = rson(o);
     if(p <= tree[lc].r)update(lc);
     else update(rc);
     for(int i = ; i < ; i++)
         tree[o].sum[i] = tree[lc].sum[i] + tree[rc].sum[((i - tree[lc].tot) %  + ) % ];
     tree[o].tot = tree[lc].tot + tree[rc].tot;
 }

 int a[maxn], b[maxn], c[maxn];
 int main()
 {
     while(scanf("%d", &n) != EOF)
     {
         char s[];
         int tot = ;
         for(int i = ; i < n; i++)
         {
             scanf("%s", s);
             if(s[] == 's')
                 a[i] = ;
             else
             {
                 scanf("%d", &b[++tot]);
                 if(s[] == 'a')
                     a[i] = ;
                 else a[i] = ;
             }
         }
         memcpy(c, b, sizeof(c));
         sort(b + , b + tot + );
         tot = unique(b + , b + tot + ) - (b + );
         build(, , tot);
         for(int i = , j = ; i < n; i++)
         {
             if(a[i] == )
             {
                 printf("%lld\n", tree[].sum[]);
             }
             else
             {
                 if(a[i] == )v = ;
                 else v = -;
                 p = lower_bound(b + , b +  + tot, c[++j]) - b;
                 x = b[p];
                 update();
             }
         }
     }
     return ;
 }