nyoj 9 poj 2528 posters

线段树的离散化，因为贴海报的范围是1~1e7，肯定开不了那么大的数组，但是n的范围很小只有1e4，所以可以离散化处理，什么叫做离散化？
百度百科：离散化，把无限空间中无限的个体映射到有限的空间中去，以此提高算法的时空效率。
比如一组数据：
3
10000 100000
10000 20000
20000 100000
心算就能算出来应该是3，我们可以把10000假设成1，100000假设成10，20000假设成2，这样就成了
3
1 10
1 2
2 10
其实还可以继续缩小 因为10000最小排在第一，20000第二，100000第三，所以假设10000为1，20000为2，100000为3
即：
3
1 3
1 2
2 3
因此离散化就避免了很大的空间浪费，所以虽然说数的范围是1~1e7，但是只有2e4个数，我们通过映射，可以将这些数映射成1~20000的范围，这样就只需要开2w的数组即可，而不再需要开1e7的数组，是不是很神奇啊？哈哈~
不过应该怎么映射？
可以通过map映射，不过可能会超时，我们可以将所有的数sort一下，再去重，然后每个数都对应了一个次序，按照这个次序来建树，更新，最后再求范围就可以了，
poj：

http://poj.org/problem?id=2528

poj AC代码（nyoj wa）：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
using namespace std;
int num[20010],k,c[20010];
struct node
{
    int left,right,value,mid;
} w[80020];
struct stu
{
    int x,y;
} a[10010];
void build(int l,int r,int tr)
{
    w[tr].value=-1;
    w[tr].left=l,w[tr].right=r;
    if(l==r)  return ;
    int mid=(l+r)/2;
    w[tr].mid=mid;
    build(l,mid,tr*2);
    build(mid+1,r,tr*2+1);
}
int Search(int x)
{
    int l=1,r=k,j;
    while(l<=r)
    {
        j=(l+r)/2;
        if(num[j]==x)
            return j;
        if(x<num[j])
            r=j-1;
        else
            l=j+1;
    }
}
void update(int l,int r,int zhi,int tr)
{
    if(l==w[tr].left&&r==w[tr].right)
    {
        w[tr].value=zhi;
            return ;
    }
    if(w[tr].value!=-1)
     w[tr*2].value=w[tr*2+1].value=w[tr].value,w[tr].value=-1;
    if(r<=w[tr].mid)
        update(l,r,zhi,tr*2);
    else if(l>w[tr].mid)
        update(l,r,zhi,tr*2+1);
    else
        update(l,w[tr].mid,zhi,tr*2),update(w[tr].mid+1,r,zhi,tr*2+1);
}
void searchtree(int tr)
{
    if(w[tr].value!=-1)
        {c[w[tr].value]++;return;}
    if(w[tr].left==w[tr].right)  {return;}
    searchtree(tr*2),searchtree(tr*2+1);
}
int main()
{
    int nn;
    scanf("%d",&nn);
    while(nn--)
    {
        memset(c,0,sizeof(c));
        int n,i;
        k=0;
        scanf("%d",&n);
        for(i=1; i<=n; i++)
            scanf("%d%d",&a[i].x,&a[i].y),num[++k]=a[i].x,num[++k]=a[i].y;
        sort(num+1,num+k+1);
        k=unique(num+1,num+k+1)-num-1;
        build(1,k,1);
        for(i=1; i<=n; i++)
        {
            int x=Search(a[i].x);
            int y=Search(a[i].y);
            update(x,y,i,1);
        }
        searchtree(1);
        int s=0;
        for(i=1; i<=n; i++)
            if(c[i])
                s++;
        printf("%d\n",s);
    }
}

然后换个oj提交

http://acm.nyist.net/JudgeOnline/problemset.php

这是会惊奇的发现wa了，为什么？
再来测一组数据
3
1 10
1 4
6 10
实际结果应该为3，但是代码的结果为2，为什么？
因为映射过程中成了：
3
1 4
1 2
3 4
不难理解为什么代码结果和实际为什么不一样，但是poj后台数据水，就a了，，幸亏我nyoj后台叼~，哈哈，，
改进代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<set>   //set用来记录海报个数
#include<iostream>
using namespace std;
set<int>s;   //set容器
int num[20010],k;
struct node
{
    int left,right,value,mid;
} w[40020];
struct stu
{
    int x,y;
} a[10010];
void build(int l,int r,int tr)   //建树，但是不是一般的建树法
{
    w[tr].value=-1;
    w[tr].left=l,w[tr].right=r;
    int mid=(l+r)/2;
    w[tr].mid=mid;
    if(l+1<r)   //注意此处的建树法
    {
        build(l,mid,tr*2);
        build(mid,r,tr*2+1);
    }
}
int Search(int x)  //二分查找用来查找这个数对应的是离散化的哪个数字，
{
    int l=1,r=k,j;
    while(l<=r)
    {
        j=(l+r)/2;
        if(num[j]==x)
            return j;
        if(x<num[j])
            r=j-1;
        else
            l=j+1;
    }
}
void update(int l,int r,int zhi,int tr)  //区间更新
{
    if(l==w[tr].left&&r==w[tr].right)    //若查找到此区间，则“贴上海报”
    {
        w[tr].value=zhi;
        return ;
    }
    if(w[tr].value!=-1)  //若此区间没有找到，且此处有海报，就将其分成小块，
        w[tr*2].value=w[tr*2+1].value=w[tr].value,w[tr].value=-1;
    if(r<=w[tr].mid)
        update(l,r,zhi,tr*2);
    else if(l>=w[tr].mid)
        update(l,r,zhi,tr*2+1);
    else
        update(l,w[tr*2].right,zhi,tr*2),update(w[tr*2+1].left,r,zhi,tr*2+1);
}
void searchtree(int tr)  //查询
{
    if(w[tr].value!=-1)
      s.insert(w[tr].value);   //找到海报就放进set容器中，同时这个区间的子区间就不再统计，
    else if(w[tr].right>w[tr].left+1) 
    {
        searchtree(2*tr);
        searchtree(2*tr+1);
    }
}
int main()
{
    int nn;
    scanf("%d",&nn);
    while(nn--)
    {
        int n,i;
        k=0;
        scanf("%d",&n);
        for(i=1; i<=n; i++)
            scanf("%d%d",&a[i].x,&a[i].y),a[i].x--,num[++k]=a[i].x,num[++k]=a[i].y;  //num数组用来排序，便于离散化，至于为什么要a[i]--，自己想想，哈哈~
        sort(num+1,num+k+1);   //num排序，
        k=unique(num+1,num+k+1)-num-1;  //用了unique函数，目的是去除排序后的重复数字，
        build(1,k,1);  //建树
        for(i=1; i<=n; i++)  //n次更新
        {
            int x=Search(a[i].x);
            int y=Search(a[i].y);
            update(x,y,i,1);
        }
        searchtree(1);  //查询有多少个海报
        printf("%d\n",s.size());  //输出海报个数
        s.clear();  //清空set容器
    }
    return 0;
}