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 + 5;
struct data {
    int l , r , sum;
}T[MAXN << 2];
map <int , int> mp;
int x[MAXN] , y[MAXN] , cont , id[MAXN];

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

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

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

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