POJ 2528 - Mayor's posters

本题每次的更新区间为[1,10000000]，区间较大，但是由于更新操作最多为10000条。从中可知数据的区间结点最多有20000个。将结点离散化后，可以节省很多空间。

离散化：把无限空间中有限的个体映射到有限的空间中去，以此提高算法的时空效率。

离散化之前：

离散化之后：

本题数据有点弱，由于离散化后，可能导致之间有间隔的结点变成相邻的结点了，会影响答案。要把这些离散化后的结点之间插入一些结点即可。
测试数据见程序尾部的注释。

---

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define lson rt << 1
#define rson rt << 1 | 1
using namespace std;
int maxn[40500 << 2], lazy[40500 << 2], ans[40500];
int v[20500 << 1], cnt, tmp;
void build()
{
    memset(maxn, 0, sizeof(maxn));
    memset(lazy, 0, sizeof(lazy));
}
void pushdown(int rt)
{
    if(lazy[rt])
    {
        maxn[lson] = maxn[rson] = lazy[rt];
        lazy[lson] = lazy[rson] = lazy[rt];
        lazy[rt] = 0;
    }
}
void update(int l, int r, int rt, int L, int R, int val)
{
    if(v[l] >= L && v[r] <= R)
    {
        maxn[rt] = val;
        lazy[rt] = val;
        return ;
    }
    pushdown(rt);
    int mid = (l + r) >> 1;
    if(L <= v[mid]) update(l, mid, lson, L, R, val);
    if(R > v[mid]) update(mid + 1, r, rson, L, R, val);
}
void query(int l, int r, int rt)
{
    if(l == r)
    {
        if(maxn[rt])
            ans[tmp++] = maxn[rt];
        return ;
    }
    pushdown(rt);
    int mid = (l + r) >> 1;
    query(l, mid, lson);
    query(mid + 1, r, rson);
}
int main()
{
    pair<int, int> s[10005];
    int T, n;
    while(~scanf("%d", &T))
    {
        while(T--)
        {
            tmp = cnt = 0;
            build();
            scanf("%d", &n);
            for(int i = 1; i <= n; i++)
            {
                int x, y;
                scanf("%d %d", &x, &y);
                s[i].first = x;
                s[i].second = y;
                v[cnt++] = x;
                v[cnt++] = y;
            }
            sort(v, v + cnt);
            cnt = unique(v, v + cnt) - v;
            int ttt = cnt;
            for(int i = 1; i < cnt; i++)
            {
                if(v[i] - v[i-1] > 1) v[ttt++] = v[i] - 1;
            }
            sort(v, v + ttt);
            for(int i = 1; i <= n; i++)
            {
                update(0, ttt - 1, 1, s[i].first, s[i].second, i);
            }
            query(0, ttt - 1, 1);
            sort(ans, ans + tmp);
            int a = unique(ans, ans + tmp) - ans;
            printf("%d\n", a);
        }
    }
    return 0;
}
/*
3
3
5 6
4 5
6 8
3
1 10
1 3
6 10
5
1 4
2 6
8 10
3 4
7 10
*/