poj 2528

题意：有n(1~10000)个市长的候选人，这个城市专门为他们安排了一个长为10000000的墙，他们每人可以按顺序帖自己的竞选海报到墙上，所有的海报与墙一样高，分别帖在墙的[a[i],b[i]]区间上。问最后能露出来被看到的海报有多少张。

 

思路：线段树+离散化。由于长度太大，无法直接建树，而n最大只有10000，故因考虑离散化。

      例：区间[1,6], [1,7], [2,10], [8,18]

      离散化后的结果为：区间[1,3], [1,4], [2,6], [5,7]。

      很明显，会节约了很多的空间，但是每个区间的覆盖关系不会改变，这点是最关键的。

      另外，至于判断每一个有没有露出来的空间，方法为：从后往前帖，先帖到的区间就是用过的，然后如果有一张海报帖到的区间都是用过的，则说明它不能露出来了。

 代码如下：

#include<iostream>
#include<algorithm>
using namespace std;
const int Max = 25000;

struct
{
    int l, r;
    bool vis;
}node[3*Max];

struct data
{
    int pos, num;
}post[Max];

bool flag;

bool cmp1(data &a, data &b)
{
    if(a.pos < b.pos) 
		return true;
    return false;
}

bool cmp2(data &a, data &b)
{
    if(a.num > b.num) 
		return true;
    if(a.num == b.num && a.pos < b.pos) 
		return true;
    return false;
}

void BuildTree(int left, int right, int u)
{        //  建树。
    node[u].l = left;
    node[u].r = right;
    node[u].vis = false;
    if(left == right) 
		return;
    int mid = (left+right)>>1;
    BuildTree(left, mid, u<<1);
    BuildTree(mid+1, right, (u<<1)+1);
}

void query(int left, int right, int u)
{            //  查询。
    if(node[u].vis == true) 
		return;
    if(node[u].l == left && node[u].r == right)
	{
        node[u].vis = true;       //  修改。
        flag = true;              //  对于新帖的海报，有区间可以让其露出来。
        return;
    }
    if(right <= node[u<<1].r)
        query(left, right, u<<1);
    else if(left >= node[(u<<1)+1].l)
        query(left, right, (u<<1)+1);
    else
	{
        query(left, node[u<<1].r, u<<1);
        query(node[(u<<1)+1].l, right, (u<<1)+1);
    }
    //  *递归回来的时候，由于左右子结点性质的改变，必须对父结点信息进行相应的更改。
    node[u].vis = node[u<<1].vis & node[(u<<1)+1].vis;
}

int main()
{
    int t, n, i;
    scanf("%d", &t);
    while(t--)
	{
        scanf("%d", &n);
        for(i = 0; i < n; i ++)
		{
            scanf("%d%d", &post[2*i].pos, &post[2*i+1].pos);
            post[2*i].num = post[2*i+1].num = i;
        }
        sort(post, post + 2*n, cmp1);
        int k = 0, pre = 0;             //  离散化。
        for(i = 0; i < 2*n; i ++)
		{
            if(post[i].pos != pre)
			{
                pre = post[i].pos;
                post[i].pos = ++ k;
            }
            else post[i].pos = k;
        }
        BuildTree(1, k, 1);
        sort(post, post + 2*n, cmp2);   //  按贴的顺序从后往前排。
        int ans = 0;
        for(i = 0; i < 2*n; i += 2)
		{
            int left = post[i].pos;
            int right = post[i+1].pos;
            flag = false;
            query(left, right, 1);
            if(flag) 
				ans ++;
        }
        printf("%d\n", ans);
    }
    return 0;
}