hiho #1079 离散化

#1079 : 离散化

时间限制: 10000ms

单点时限: 1000ms

内存限制: 256MB

描述

小Hi和小Ho在回国之后，重新过起了朝7晚5的学生生活，当然了，他们还是在一直学习着各种算法~

这天小Hi和小Ho所在的学校举办社团文化节，各大社团都在宣传栏上贴起了海报，但是贴来贴去，有些海报就会被其他社团的海报所遮挡住。看到这个场景，小Hi便产生了这样的一个疑问——最后到底能有几张海报还能被看见呢？

于是小Ho肩负起了解决这个问题的责任：因为宣传栏和海报的高度都是一样的，所以宣传栏可以被视作长度为L的一段区间，且有N张海报按照顺序依次贴在了宣传栏上，其中第i张海报贴住的范围可以用一段区间[a_i, b_i]表示，其中a_i, b_i均为属于[0, L]的整数，而一张海报能被看到当且仅当存在长度大于0的一部分没有被后来贴的海报所遮挡住。那么问题就来了：究竟有几张海报能被看到呢？

提示一：正确的认识信息量

提示二：小Hi大讲堂之线段树的节点意义

输入

每个测试点（输入文件）有且仅有一组测试数据。

每组测试数据的第1行为两个整数N和L，分别表示总共贴上的海报数量和宣传栏的宽度。

每组测试数据的第2-N+1行，按照贴上去的先后顺序，每行描述一张海报，其中第i+1行为两个整数a_i, b_i，表示第i张海报所贴的区间为[a_i, b_i]。

对于100%的数据，满足N<=10^5，L<=10^9，0<=a_i

输出

对于每组测试数据，输出一个整数Ans，表示总共有多少张海报能被看到。

样例输入

5 10
4 10
0 2
1 6
5 9
3 4

样例输出

5

首先L的范围太大，需要对区间进行离散化，使范围变到O(n)内。每次贴一张海报，在对应区间覆盖上海报的编号，最后看一共剩下多少个不同的编号。

需要注意的是[1,2],[2,3],[3,4]是算3张海报，因为海报实际上是一个连续的区间，所以下标为i对应的是[i,i+1]的区间。所以对于区间[a,b]，线段树更新的节点范围是[a,b-1]。然后用线段树求解，每次贴海报进行O(logn)区间更新，用data数组存储对应区间的海拔编号，最后全部海报贴完后还要对线段树进行一次O(n)遍历使所有的lazy值更新到每一个位置上。

#include 
#include 
#include 
#include 

using namespace std;

#define maxn 100005

int a[maxn], b[maxn];
int c[2*maxn];

int n, l;

int compress() //坐标离散化
{
    memcpy(c, a, sizeof(a));
    memcpy(c+n, b, sizeof(b));

    sort(c, c+2*n);
    int size = unique(c, c+2*n)-c;

    for(int i = 0; i < n; i++){
        a[i] = lower_bound(c, c+size, a[i])-c;
        b[i] = lower_bound(c, c+size, b[i])-c;
    }

    return size-1;
}

struct node
{
    node(){}
    node(int ll, int rr) { l = ll;  r = rr;}
    int l, r;
    int lazy;
};

node tree[4*maxn];
int data[maxn]; //存储对应区间海报编号

void build(int rt, int l, int r)
{
    tree[rt] = node(l, r);
    tree[rt].lazy = 0;
    if(l == r) return;

    int m = l+(r-l)/2;
    build(2*rt, l, m);
    build(2*rt+1, m+1, r);
}


void seg_modify(int rt, int ll, int rr, int v)
{
    int l = tree[rt].l, r = tree[rt].r;
    int &lazy = tree[rt].lazy;
    int lc = 2*rt, rc = 2*rt+1;

    if(l == ll && r == rr){     //懒惰更新
        lazy = v;
        return;
    }
    else{
        if(lazy){
            tree[lc].lazy = lazy;
            tree[rc].lazy = lazy;

            lazy = 0;
        }
    }

    int m = l+(r-l)/2;
    if(rr <= m)
        seg_modify(lc, ll, rr, v);
    else if(ll > m)
        seg_modify(rc, ll, rr, v);
    else{
        seg_modify(lc, ll, m, v);
        seg_modify(rc, m+1, rr, v);
    }

}

void traverse(int rt)   //遍历线段树，使所有懒惰值真正赋值到data数组上
{
    int l = tree[rt].l, r = tree[rt].r;
    int lc = 2*rt, rc = 2*rt+1;
    if(l == r){
        data[l] = tree[rt].lazy;
        return;
    }

    if(tree[rt].lazy){
        tree[lc].lazy = tree[rt].lazy;
        tree[rc].lazy = tree[rt].lazy;
    }

    traverse(lc);
    traverse(rc);
}

int main()
{
    while(~scanf("%d%d", &n, &l)){
        for(int i = 0; i < n; i++)
            scanf("%d%d", a+i, b+i);

        l = compress();
        build(1, 0, l-1);

        for(int i = 0; i < n; i++)
            seg_modify(1, a[i], b[i]-1, i+1);
        traverse(1);


        sort(data, data+l);
        int ans = unique(data, data+l)-data;
        if(!data[0]) ans--;
        printf("%d\n", ans);
    }
    return 0;
}