POJ - 2528 Mayor's posters（区间覆盖，离散化）

POJ - 2528 Mayor’s posters

题目

给出 n 段区间，区间按给出的顺序会覆盖掉前面的区间，问最后能看到多少不同的区间。

分析

这题只需要用到懒惰标记即可，线段树没有维护什么东西，有懒惰标记 c 代表这个区间被 c 覆盖了。

只不过要用到离散化，题目给出的数据我们只在乎他们的相对大小，相对大小才会影响到区间覆盖的结果 。

通常离散化的时侯是离散到连续的区间，但是有问题，比如数据：
1 - 10
1 - 4
6 - 10

普通的离散为
1 -> 1
4 -> 2
6 -> 3
10 -> 4

那么数据变为：
1 -> 4
1 -> 2
3 -> 4
答案显然不对，应该是3，结果为2.

正确的离散化应该在两个连续的大于 1 的数之间加一个数，再离散。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <set>
#include <algorithm>
#define INF 0x3f3f3f3f
#define d(x) cout << (x) << endl
#define lson l, m, rt<<1
#define rson m+1, r, rt<<1|1

// #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 9999991;
const int N = 2e5 + 10;

int t, n, cnt, m, ans;
int a[N], b[N];         //左右区间
int tmp[N];             //离散化数组
int tr[N << 2];         // 线段树什么也不维护，只用到懒惰标记
set<int> s;             // 映射关系 

void pushdown(int rt){
    if(tr[rt] != -1){
        tr[rt << 1] = tr[rt << 1 | 1] = tr[rt];
        tr[rt] = -1;
    }
}

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

void query(int l, int r, int rt){
    if(tr[rt] != -1){
        if(!s.count(tr[rt])){
            ans++;
            s.insert(tr[rt]);
        }
        return;
    }
    if(l == r)
        return;
    int m = l + r >> 1;
    query(lson);
    query(rson);
}

int bi(int key, int n, int *tmp){
    int l = 0, r = n - 1;
    while(l <= r){
        int m = l + r >> 1;
        if(tmp[m] == key){
            return m;
        }
        if(tmp[m] < key){
            l = m + 1;
        }else{
            r = m - 1;
        }
    }
    return -1;
}


int main()
{
    cin >> t;
    while(t--){
        cnt = 0;
        memset(tr, -1, sizeof(tr));     //开始都没被染色
        scanf("%d", &n);
        for(int i = 0; i < n; i++){
            scanf("%d%d", &a[i], &b[i]);
            tmp[cnt++] = a[i];
            tmp[cnt++] = b[i];
        }
        sort(tmp, tmp + cnt);
        m = 1;                         
        for(int i = 1; i < cnt; i++){   //去重
            if(tmp[i] != tmp[i-1]){
                tmp[m++] = tmp[i];
            }
        }
        for(int i = m-1; i > 0; i--){
            if(tmp[i] != tmp[i-1]+1){
                tmp[m++] = tmp[i - 1] + 1;
            }
        }
        sort(tmp, tmp + m);
        // for(int i = 0; i < m; i++){
        //     cout << tmp[i] << endl;
        // }
        for (int i = 0; i < n; i++){
            int l = bi(a[i], m, tmp);
            int r = bi(b[i], m, tmp);
            // printf("%d %d\n", l, r);
            update(0, m, 1, l, r, i);
        }
        ans = 0;
        s.clear();
        query(0, m, 1);
        printf("%d\n", ans);
    }
    return 0;
}