poj 2528 Mayor's posters(线段树+区间离散化)

题目大意：

        有一面墙，墙上铺着瓷砖，有n张海报，每张海报是从第a块瓷砖到第b块瓷砖，从第一张海报开始贴，贴到第n张海报的时候，问有多少张海报没有被完全覆盖。

解题思路：

        从最后一张海报开始反着贴，如果当前要贴的区间没有完全被覆盖则当前这张海报可以被看见，答案加1。

        由于瓷砖有10000000块，直接使用线段树，空间耗费过大，所以使用离散化分解区间。以为最多有10000张海报，所以区间最多有个40000个，效率大大提升。

注意：

         区间离散画的时候不能只根据端点离散化，比如两组数据：

        ①[1,5] [1,2] [4,5] 

        ②[1,5] [1,3] [4,5]

        如果只按照端点离散化，这两组数据离散的结果都是[1,4] [1,2] [3,4] ,表示第一张海报被第二、第三张海报覆盖，而数据①中第一张海报没有被覆盖。

        所以在离散化的时候如果相邻两个端点间还有区间，那么也需要给这个区间编号。这也个区间为什么最多是40000的原因。

代码：

#include <iostream>
#include <stdio.h>
#include <algorithm>

using namespace std;

struct node{
    int l,r;
    bool coverd;//true代表完全覆盖，false代表没有完全覆盖
};

node tree[1600005];
int a[40005],nCount,ans,n;
int hashN[10000005];
int posterL[20005],posterR[20005];

void buildTree(int root,int l,int r){//建树
    tree[root].l = l;
    tree[root].r = r;
    tree[root].coverd = false;
    if(l != r){
        int mid = (l+r)/2;
        buildTree(2*root,l,mid);
        buildTree(2*root+1,mid+1,r);
    }
}

void post(int root,int l,int r){//把区间[l,r]标记成true，代表已经被覆盖
    if(l == tree[root].l && r == tree[root].r){
        tree[root].coverd = true;
        return;
    }
    int mid = (tree[root].l + tree[root].r)/2;
    if(r <= mid){
        post(2*root,l,r);
    }
    else if(l > mid){
        post(2*root+1,l,r);
    }
    else{
        post(2*root,l,mid);
        post(2*root+1,mid+1,r);
    }
    if(tree[2*root].coverd && tree[2*root+1].coverd){
        tree[root].coverd = true;
    }
}

bool query(int root,int l,int r){//查询区间[l,r]，是否没有被完全被覆盖
    if(tree[root].coverd) return false;
    if(l == tree[root].l && r == tree[root].r){
        return !tree[root].coverd;
    }
    int mid = (tree[root].l + tree[root].r)/2;
    if(r <= mid){
        return query(2*root,l,r);
    }
    else if(l > mid){
        return query(2*root+1,l,r);
    }
    else{
        return query(2*root,l,mid) || query(2*root+1,mid+1,r);
    }
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        nCount = 0;
        ans = 0;
        scanf("%d",&n);
        for(int i = 0; i < n; i ++){
            scanf("%d%d",&posterL[i],&posterR[i]);
            a[nCount++] = posterL[i];
            a[nCount++] = posterR[i];
        }
        sort(a,a+nCount);
        nCount = unique(a,a+nCount) - a;
        //区间离散化
        int nNum = 1;
        for(int i = 0; i < nCount; i ++){
            hashN[a[i]] = nNum;
            if(i < nCount - 1){
                if(a[i+1] - a[i] == 1){
                    nNum ++;
                }
                else{
                    nNum += 2;
                }
            }
        }
        buildTree(1,1,nNum);
        for(int i = n-1; i >= 0; i --){
            if(query(1,hashN[posterL[i]],hashN[posterR[i]])){
                ans ++;
            }
            post(1,hashN[posterL[i]],hashN[posterR[i]]);
        }
        printf("%d\n",ans);
    }
    return 0;
}