pku2528(线段树加离散化）

悲剧呀，这道题目搞了那么久，原来是离散化的方法出现问题了，悲剧，实在悲剧

线段树 + 离散化
今天做了这道题目的时候, 也算是明白了 离散化 的基本
意思,因为 题目的 数据范围很大 , 1- 10000000，直接线段树的话, 先不说
内存会不会爆, 这么大的范围估计也是 TLE了.
仔细读题, 可以看到 1<= N <= 10000, 也就是说 最多只有 10000个点, 如果
每个点都不同, 那么最多也只有 20000 个数据, 那么离散后的 范围就相当小;

离散化 的大概思路 : 比如说给你一组 数据 1 4 1000 100000， 如果直接
开线段, 显然是浪费, 那么我们只要 进行 映射 :
1 1
4 2
1000 3
100000 4
接下来 我们只要对 1 2 3 4 建立线段树就行了 只需要
[1,4]的区间

嘿嘿，这个是刚写的代码，简洁了许多，也快了一点

#include<iostream>
#include<map>
#include<set>
#define MAXN 10010
using namespace std;
struct node
{
int c;
}p[MAXN*8];
int left1[MAXN],right1[MAXN],n,m,num;
bool col[MAXN];
map<int,int> map1;
map<int,int>::iterator it;
void bulid(int k,int s,int t)
{
if(t==s) return ;
p[k].c=0;
int kl=k<<1,kr=kl+1,mid=(s+t)>>1;
bulid(kl,s,mid);
bulid(kr,mid+1,t);
}
void insert(int k,int s,int t,int l,int r,int e)
{
if(l>t||r<s) return ;
if(l<=s&&t<=r)
{
p[k].c=e;
return ;
}
int kl=k<<1,kr=kl+1,mid=(s+t)>>1;
if(p[k].c!=-1)
{
p[kl].c=p[kr].c=p[k].c;
p[k].c=-1;
}
insert(kl,s,mid,l,r,e);
insert(kr,mid+1,t,l,r,e);
}
void query(int k,int s,int t)
{
if(p[k].c!=-1)
{
if(!col[p[k].c])
{
num++;
col[p[k].c]=true;
}
return ;
}
int kl=k<<1,kr=kl+1,mid=(s+t)>>1;
query(kl,s,mid);
query(kr,mid+1,t);
}

int main()
{
int cas;
scanf("%d",&cas);
while(cas--)
{
map1.clear();
scanf("%d",&m);
for(int i=0;i<m;i++)
{
scanf("%d %d",&left1[i],&right1[i]);
map1[left1[i]]=10;
map1[right1[i]]=10;
}
it=map1.begin();
int i=1;
for(;it!=map1.end();i++,it++)
it->second=i;
n =i;
bulid(1,1,n);
for(int i=0;i<m;i++)
insert(1,1,n,map1[left1[i]],map1[right1[i]],i+1);
num=0;
memset(col,false,sizeof(col));
col[0]=true;
query(1,1,n);
printf("%d\n",num);
}
return 0;
}

#include<set>
#include<map>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
using namespace std;
#define MAX_N  20010
struct In
{
int left;
int right;
}str[MAX_N];
struct Node
{
int l;
int r;
int col;
}p[8*MAX_N];
set<int> my_set;
map<int,int> mp;
map<int,int>::iterator beg,end1;
int cmp( const void *a , const void *b ){
return *(int *)a-*(int *)b;
}
void bulid(int k,int s,int t)
{
int kr,kl,mid;
p[k].l=s;p[k].r=t;p[k].col=0;
if(s==t)
return ;
mid=(s+t)>>1;kl=k<<1;kr=kl+1;
bulid(kl,s,mid);
bulid(kr,mid+1,t);
}
void insert(int k,int s,int t,int v)
{
int kr,kl,mid;
if(s==p[k].l&&t==p[k].r)
{
p[k].col=v;
}
else {
mid=(p[k].l+p[k].r)>>1;kl=k<<1;kr=kl+1;
if(p[k].col!=-1)
{
p[kl].col=p[kr].col=p[k].col;
p[k].col=-1;
}
if(t<=mid) insert(kl,s,t,v);
else if(s>mid) insert(kr,s,t,v);
else {
insert(kl,s,mid,v);
insert(kr,mid+1,t,v);
}
}
}
void query(int k,int s,int t)
{
if(p[k].col!=-1)
{
my_set.insert(p[k].col);//将颜色插入set中，自动去重
return ;
}
int mid=(p[k].r+p[k].l)>>1,kl=k<<1,kr=kl+1;
if(t<=mid) query(kl,s,t) ;
else if(s>mid) query(kr,s,t);
else {
query(kl,s,mid);query(kr,mid+1,t);
}
}
int main()
{
int i,j,cas,n,m,num;
scanf("%d",&cas);
bulid(1,1,MAX_N);
while(cas--)
{
my_set.clear();
mp.clear();
scanf("%d",&n);
for(i=1;i<=n;i++)
{
scanf("%d %d",&str[i].left,&str[i].right);
mp[str[i].left] = 10; mp[str[i].right] = 10;
}
beg = mp.begin(), end1 = mp.end();
insert(1,1,2*n,0);
//因为map 已经自动排序了,所以直接从 1 --> N 开始标记, 离散化
for ( int i = 1;beg != end1; ++ beg, ++ i ) {
beg->second = i;
}
//因为线段树已经建立好了, 所以没必要每次都重建一次, 只要插入一条
//覆盖所有区间的 底板 就行了
for ( int i = 1; i <= n; ++ i ) {
//用离散后的标记 插入 线段
insert ( 1,mp[str[i].left], mp[str[i].right], i );
}
query(1,1,2*n);
num=my_set.size();//返回集合中元素个数
if(*my_set.begin()==0)
num--;
printf("%d\n",num);
}
return 0;
}