POJ 2528 （线段树+离散化）

#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=20005;
int pl[maxn],pr[maxn],n;
int col[maxn*8];
int vis[maxn]= {0};
int ans=0;
int id[maxn*4];
void build_tree(int l,int r,int rt)
{
//    ll[rt]=l;
//    rr[rt]=r;
    col[rt]=0;
   if(l==r)
    return ;
        build_tree(l, (l + r) / 2, rt << 1);
        build_tree((l + r) / 2 + 1, r, rt << 1 | 1);

}
void add(int l,int r,int k,int l2,int r2,int v)
{
    if(l>=l2&r<=r2)
    {
        col[k]=v;
        return ;
    }
    if(col[k])
    {
        col[k * 2] = col[k];
        col[k * 2 + 1] = col[k];
//        cout<<"///"<<k<<" "<<col[k]<<endl;
        col[k]=0;
    }
        int mid = (l + r) / 2;
        //cout<<"///"<<mid<<endl;
        if(l2 <= mid)
            add(l, mid, k* 2, l2, r2, v);
        if(r2 > mid)
            add(mid + 1, r, k * 2 + 1, l2, r2, v);

}
void res(int  l,int  r,int  k)
{
//    cout<<col[k]<<endl;

        if(col[k] != 0)
        {
            if(vis[col[k]] == 0)
            {
                ans++;
                vis[col[k]] = 1;
            }
            return;
        }
        if(l == r)
            return;
        int mid = (l + r) / 2;
        res(l, mid, k * 2);
        res(mid + 1, r, k * 2 + 1);
}
    int main()
    {

        cin>>n;
        while(n--)
        {
            int w = 0;
            int k = 0;
            int m = 0;
            int mm;
            memset(vis, 0, sizeof(vis));
            memset(pl, 0, sizeof(pl));
            memset(col, 0, sizeof(col));
            memset(pr, 0, sizeof(pr));
            memset(id, 0, sizeof(id));
            int oo;
            cin>>oo;
            for(int i=0; i<oo; i++)
            {
                cin>>pl[i]>>pr[i];
                id[m++]=pl[i];
                id[m++]=pr[i];
            }
            sort(id,id + m);
            mm = unique(id, id +m) - id;//     去重
            int mmm=mm;
            for(int i=1; i<mmm; ++i)
            {
                if(id[i]-id[i-1]!=1)
                    id[mm++]=id[i-1]+1;      //相差大于1的位置要加入一个点！！！！
            }
            sort(id,id+mm);

            build_tree(1, mm, 1);

            for(int i=0; i<oo; ++i)
            {
                int l=lower_bound(id,id+mm,pl[i])-id;
                int r=lower_bound(id,id+mm,pr[i])-id;
                //lower_bound   二分查找位置    会有0
                add(1, mm, 1,l+1,r+1, i + 1);
            }
            ans = 0;
            res(1, mm, 1);
            cout<<ans<<endl;
        }


    }