POJ 2528 线段树 + 延迟标记 + 离散化

通过这道题学到了很多知识，总结了以后有以下两点：

1.线段树的创建只是一个初始化的过程，如果初始化的值都为0的话，只需要memset，根本无需写一个递归建树的过程

2.离散化，当点的数目很少，但是点的值又很大的时候，可以考虑离散化，既可以降低复杂度，又不至于爆内存。

本题就是不断的用所给区间染色，最后再查询有多少种颜色就可以了。

此题中还有一个wa点，如果用普通的离散化的话，考虑一下这组数据：

1 7

1 2

5 7

正确答案应该是3吧。

可是离散化之后x[1] = 1, x[2] = 2, x[3] = 5,  x[4] = 7。

这样一来就相当于

1 4

1 2

3 4

答案就变成2了。

问题出在哪呢？ 其实是因为2和5之间本来是有间隔的，可是离散化之后就变成相邻的了。也就是顺序相邻，位置不相邻。那么该怎么解决这个问题呢？其实很简单，只要在2和5中间加入一个4就行了，这样就变成了顺序不相邻，位置不相邻。

代码如下：

#include <algorithm>
#include <iostream>
#include <iterator>
#include <sstream>
#include <fstream>
#include <istream>
#include <ostream>
#include <complex>
#include <cstring>
#include <utility>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <string>
#include <cctype>
#include <ctime>
#include <cmath>
#include <queue>
#include <stack>
#include <list>
#include <new>
#include <set>
#include <map>
#define lson l, m, k << 1
#define rson m + 1, r, k << 1| 1

using namespace std;

typedef long long int LL;
const int INF = 0x3f3f3f3f;
const int maxn = 50005 << 2;
int mark[maxn], value[maxn], Hash[maxn], li[maxn], ri[maxn], x[maxn];
int cnt;

void pushup(int k){
    if (value[k << 1] == value[k << 1 | 1])
        value[k] = value[k << 1];
    else value[k] = 0;//wa了无数次，才发现少写了这一步
}

void pushdown(int k){
    if (mark[k]){
        mark[k << 1] = mark[k << 1| 1] = 1;
        mark[k] = 0;
        value[k << 1] = value[k << 1| 1] = value[k];
        value[k] = 0;
    }
}

void update(int l, int r, int k, int L, int R, int c){
    if (L <= l && R >= r){
        mark[k] = 1;
        value[k] = c;
        return;
    }
    pushdown(k);
    int m = (l + r) >> 1;
    if (L <= m) update(lson, L, R, c);
    if (R > m) update(rson, L, R, c);
    pushup(k);
}

void query(int l, int r, int k){
    if (value[k]){
        if (!Hash[value[k]]){
            cnt++;
            Hash[value[k]] = 1;
        }
        return;
    }
    if (l == r) return;
    int m = (l + r) >> 1;
    query(lson);
    query(rson);
}

int Binary_Search(int s, int e, int key) {
    int left = s, right = e, mid;
    while (left <= right) {
        mid = (left + right) >> 1;
        if (x[mid] >= key)  right = mid - 1;
        else left = mid + 1;
    }
    if (x[left] == key) return left;
    else return -1;
}

int main()
{
    //freopen("1.txt", "r", stdin);
    int T;
    scanf("%d", &T);
    while (T--){
        int n, m;
        scanf ("%d", &n);
        int nn = 0;
        for (int i = 1; i <= n; i++) {
             scanf ("%d %d", &li[i], &ri[i]);
             x[++nn] = li[i];
             x[++nn] = ri[i];
        }
        sort(x+1, x+nn+1);//离散化
        m = 1;
        for (int i = 2; i <= nn; i++) {
             if (x[i] != x[i-1]) x[++m] = x[i];
        }
        for (int i = m; i > 1; i--) {//普通的离散化会有问题，问题出在位置不相邻，但是顺序相邻。所以要给相差1
                                    //以上的点中间再加一个点。
            if (x[i] - x[i-1] > 1) x[++m] = x[i] - 1;
        }
        sort(x+1, x+m+1);
        memset(value, 0, sizeof(value));//无需建树，只需要memset
        memset(mark, 0, sizeof(mark));
        for (int i = 1; i <= n; i++) {
            int l = Binary_Search(1, m + 1, li[i]);
            int r = Binary_Search(1, m + 1, ri[i]);
            update(1, m, 1, l, r, i);
        }
        cnt = 0;
        memset(Hash, 0, sizeof(Hash));
        query(1, m, 1);
        printf("%d\n", cnt);
    }
    return 0;
}