ACdream 1157 Segments（CDQ分治）

题目链接：http://acdream.info/problem?pid=1157

Problem Description

由3钟类型操作：
1）D L R(1 <= L <= R <= 1000000000) 增加一条线段[L,R]
2）C i (1-base) 删除第i条增加的线段，保证每条插入线段最多插入一次，且这次删除操作一定合法
3) Q L R(1 <= L <= R <= 1000000000) 查询目前存在的线段中有多少条线段完全包含[L,R]这个线段，线段X被线段Y完全包含即LY <= LX

<= RX <= RY)
给出N，接下来N行，每行是3种类型之一

Input

多组数据，每组数据N

接下来N行，每行是三种操作之一(1 <= N  <= 10^5)

Output

对于每个Q操作，输出一行，答案

 

题目大意：略。

思路：传说这个就叫做CDQ分治，我也不确定是不是。对每一段[l..r]，分治处理[l, mid]和[mid + 1..r]。对于[l..r]，处理[l..mid]中的线段对[mid + 1..r]的影响，用树状数组处理一下就可以了。

 

代码（1608MS）：

 #include <iostream>
 #include <algorithm>
 #include <cstring>
 #include <cstdio>
 using namespace std;

 const int MAXN = ;

 int hashmap[MAXN], hcnt;
 int tree[MAXN];

 int hash(int x) {
     return lower_bound(hashmap, hashmap + hcnt, x) - hashmap + ;
 }

 inline int lowbit(int x) {
     return x & -x;
 }

 void modify(int k, int val) {
     while(k <= hcnt) {
         tree[k] += val;
         k += lowbit(k);
     }
 }

 int get_sum(int k) {
     int res = ;
     while(k) {
         res += tree[k];
         k -= lowbit(k);
     }
     return res;
 }

 struct Node {
     int v, l, r, id;
     Node() {}
     Node(int v, int l, int r, int id): v(v), l(l), r(r), id(id) {}
     bool operator < (const Node &rhs) const {
         if(r != rhs.r) return r > rhs.r;
         if(l != rhs.l) return l < rhs.l;
         return (v == ) < (rhs.v == );
     }
 };

 bool cmp_id(const Node &a, const Node &b) {
     return a.id < b.id;
 }

 Node p[MAXN];
 int ans[MAXN], tl[MAXN], tr[MAXN];
 int n;

 void solve(int l, int r) {
     if(l == r) return ;
     int mid = (l + r) >> ;
     solve(l, mid);
     solve(mid + , r);
     sort(p + l, p + r + );
     for(int i = l; i <= r; ++i) {
         if(p[i].id <= mid) {
             if(p[i].v) modify(p[i].l, p[i].v);
         } else {
             if(!p[i].v) ans[p[i].id] += get_sum(p[i].l);
         }
     }
     for(int i = l; i <= r; ++i) {
         if(p[i].id <= mid && p[i].v) modify(p[i].l, -p[i].v);
     }
     sort(p + l, p + r + , cmp_id);
 }

 int main() {
     while(scanf("%d", &n) != EOF) {
         int tcnt = ; hcnt = ;
         char c;
         for(int i = , t, u; i <= n; ++i) {
             scanf(" %c", &c);
             if(c == 'D') {
                 scanf("%d%d", &t, &u);
                 p[i] = Node(, t, u, i);
                 hashmap[hcnt++] = t; hashmap[hcnt++] = u;
                 tl[++tcnt] = t; tr[tcnt] = u;
             }
             if(c == 'C') {
                 scanf("%d", &t);
                 p[i] = Node(-, tl[t], tr[t], i);
             }
             if(c == 'Q') {
                 scanf("%d%d", &t, &u);
                 p[i] = Node(, t, u, i);
                 hashmap[hcnt++] = t; hashmap[hcnt++] = u;
             }
         }
         sort(hashmap, hashmap + hcnt);
         hcnt = unique(hashmap, hashmap + hcnt) - hashmap;
         for(int i = ; i <= n; ++i) {
             p[i].l = hash(p[i].l); p[i].r = hash(p[i].r);
         }
         memset(ans + , , n * sizeof(int));
         solve(, n);
         for(int i = ; i <= n; ++i)
             if(p[i].v == ) printf("%d\n", ans[i]);
     }
 }