POJ 2528 Mayor's posters (线段树区间更新+离散化)

题目链接：http://poj.org/problem?id=2528

给你n块木板，每块木板有起始和终点，按顺序放置，问最终能看到几块木板。

很明显的线段树区间更新问题，每次放置木板就更新区间里的值。由于l和r范围比较大，内存就不够了，所以就用离散化的技巧 比如将1 4化为1 2，范围缩小，但是不影响答案。

写了这题之后对区间更新的理解有点加深了，重点在覆盖的理解(更新左右两个孩子节点，然后值清空)，还是要多做做题目。

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <map>
 using namespace std;
 const int MAXN = 2e4 + ;
 struct data {
     int l , r , sum;
 }T[MAXN << ];
 map <int , int> mp;
 int x[MAXN] , y[MAXN] , cont , id[MAXN];

 void init(int p , int l , int r) {
     int mid = (l + r) >> ;
     T[p].l = l , T[p].r = r;
     if(l == r) {
         T[p].sum = ;
         return ;
     }
     init(p <<  , l , mid);
     init((p << )| , mid +  , r);
     T[p].sum = T[p << ].sum + T[(p << )|].sum;
 }

 int query(int index , int p) {
     int mid = (T[p].l + T[p].r) >> ;
     if(index == T[p].l && T[p].r == index) {
         return T[p].sum;
     }
     if(T[p].sum) {
         T[p << ].sum = T[(p << )|].sum = T[p].sum;
         T[p].sum = ;
     }
     if(index <= mid) {
         query(index , p << );
     }
     else {
         query(index , (p << )|);
     }
 }

 void updata(int p , int l , int r , int val) {
     int mid = (T[p].l + T[p].r) >> ;
     if(T[p].l >= l && T[p].r <= r) { //找到了区间，更新这个区间
         T[p].sum = val;
         return ;
     }
     if(T[p].sum) {  //重点注意，如果这个区间被访问了，并且这个区间要更新，就要将这个区间的值更新到其左右孩子的节点，并且要将这个区间的值清空，这样才能算是覆盖
         T[p << ].sum = T[(p << )|].sum = T[p].sum;
         T[p].sum = ;
     }
     if(r <= mid) {
         updata(p <<  , l , r , val);
     }
     else if(l > mid) {
         updata((p << )| , l , r , val);
     }
     else {
         updata(p <<  , l , mid , val);
         updata((p << )| , mid +  , r , val);
     }
 }

 int main()
 {
     int t , n;
     scanf("%d" , &t);
     while(t--) {
         scanf("%d" , &n);
         mp.clear();
         cont = ;
         for(int i =  ; i <= n ; i++) {
             scanf("%d %d" , x + i , y + i);
             if(!mp[x[i]]) {
                 id[++cont] = x[i];
                 mp[x[i]]++;
             }
             if(!mp[y[i]]) {
                 id[++cont] = y[i];
                 mp[y[i]]++;
             }
         }
         sort(id +  , id + cont + );
         int len = -; //离散化之后的最大的数
         for(int i =  ; i <= n ; i++) { //离散化
             x[i] = lower_bound(id +  , id + cont +  , x[i]) - id;
             len = max(x[i] , len);
             y[i] = lower_bound(id +  , id + cont +  , y[i]) - id;
             len = max(y[i] , len);
         }
         init( ,  , len);
         for(int i =  ; i <= n ; i++) {
             updata( , x[i] , y[i] , i);
         }
         mp.clear();
         int res = ;
         for(int i =  ; i <= len ; i++) {
             int temp = query(i , );
             if(!mp[temp] && temp) {
                 res++;
                 mp[temp]++;
             }
         }
         printf("%d\n" , res);
     }
 }