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;
}