POJ2528 线段树 区间更新 离散化

题意：依次将给定区间染色并覆盖之前的颜色， 问最后能看见几种颜色？
思路：
1、首先li <= ri <= 1e7, 若直接建树则必定MLE \ TLE，此时便需要用到离散化处理，也是我新学到的知识。 下面是我学习离散化处理的两个网址：
http://www.matrix67.com/blog/archives/108
http://blog.csdn.net/gokou_ruri/article/details/7723378
离散化处理， 依我目前理解的程度看来， 就是将无限化有限， 选取足够的有用信息， 例如区间端点的相对位置、 可能的角度等等。
2、其次需要注意的是本题需要中间插点， 也是新学到的技巧。
下面引用一下另一位博主的解释。

离散化，如下面的例子（题目的样例），因为单位1是一个单位长度，将下面的
1 2 3 4 6 7 8 10
— — — — — — — —
1 2 3 4 5 6 7 8
离散化 X[1] = 1; X[2] = 2; X[3] = 3; X[4] = 4; X[5] = 6; X[7] = 8; X[8] = 10
于是将一个很大的区间映射到一个较小的区间之中了，然后再对每一张海报依次更新在宽度为1~8的墙上(用线段树），最后统计不同颜色的段数。
但是只是这样简单的离散化是错误的，
如三张海报为：1~10 1~4 6~10
离散化时 X[ 1 ] = 1, X[ 2 ] = 4, X[ 3 ] = 6, X[ 4 ] = 10
第一张海报时：墙的1~4被染为1；
第二张海报时：墙的1~2被染为2，3~4仍为1；
第三张海报时：墙的3~4被染为3，1~2仍为2。
最终，第一张海报就显示被完全覆盖了，于是输出2，但实际上明显不是这样，正确输出为3。
新的离散方法为：在相差大于1的数间加一个数，例如在上面1 4 6 10中间加5（算法中实际上1，4之间，6，10之间都新增了数的）
X[ 1 ] = 1, X[ 2 ] = 4, X[ 3 ] = 5, X[ 4 ] = 6， X[ 5 ] = 10
这样之后，第一次是1~5被染成1；第二次1~2被染成2；第三次4~5被染成3
最终，1~2为2，3为1，4~5为3，于是输出正确结果3。

3、如何统计最后所能见的海报/颜色？
搜索到叶节点时，将所涂颜色标记，利用bool数组，若出现新的颜色则答案加一。

反思：
1、线段树其实是很灵活的，例如本题就不需要PushUp函数、额外的懒标记数组。因为本题整棵线段树只有叶子节点存储颜色信息，而非叶子结点则用来充当懒标记。因此绝不要被模板局限了思路。
2、虽然能想出深搜到叶子结点，但是没有想出最后利用bool数组来统计的方法（感觉和桶排序很相似），看来一些基本功还是没有学扎实。
努力努力再努力！

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int MAXN = 10000 * 2 + 10;
int color[MAXN << 3], li[MAXN >> 1], ri[MAXN >> 1], map[MAXN << 1], ans;
bool hash[MAXN >> 1];
void PushDown(int rt)
{
    if(color[rt])
    {
        color[rt << 1] = color[rt << 1 | 1] = color[rt];
        color[rt] = 0;
    }
    return;
}
void Update(int L, int R, int c, int l, int r, int rt)
{
    if(L <= l && r <= R)
    {
        color[rt] = c;
        return;
    }
    int m = (l + r) >> 1;
    PushDown(rt);
    if(L <= m) Update(L, R, c, l, m, rt << 1);
    if(R > m) Update(L, R, c, m + 1, r, rt << 1 | 1);
    return;
}
void Query(int L, int R, int l, int r, int rt)
{
    if(l == r)
    {
        if(color[rt] && !hash[color[rt]])
        {
            ans++;
            hash[color[rt]] = true;
        }
        return;
    }
    int m = (l + r) >> 1;
    PushDown(rt);
    if(L <= m) Query(L, R, l, m, rt << 1);
    if(R > m)Query(L, R, m + 1, r, rt << 1 | 1);
    return;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    int t; cin >> t;
    while(t--)
    {
        int n; cin >> n;
        int cnt = 0;
        for(int i = 1; i <= n; i++)
        {
            cin >> li[i] >> ri[i];
            map[++cnt] = li[i]; map[++cnt] = ri[i];
        }

        //离散化
        sort(map + 1, map + cnt + 1);//排序
        int length = unique(map + 1, map + cnt + 1) - (map + 1);//去重
        for(int i = length; i >= 2; i--)//插点
        {
            if(map[i] - map[i-1] > 1) map[++length] = map[i] - 1;
        }
        sort(map + 1, map + length + 1);//再排序
        length = unique(map + 1, map + length + 1) - (map + 1);//再去重

        memset(color, 0, sizeof(color));
        memset(hash, false, sizeof(hash));
        for(int i = 1; i <= n; i++)
        {
            int l = lower_bound(map + 1, map + length + 1, li[i]) - map;
            int r = lower_bound(map + 1, map + length + 1, ri[i]) - map;
            Update(l, r, i, 1, length, 1);
        }
        ans = 0;
        Query(1, length, 1, length, 1);
        cout << ans << endl;
    }
}