Gym 100490E-E - Environment Problems- 伸展树/平衡树/离散化点

题意：n次操作

操作1给区间【a,b】加上1

操作2查询某个点x的值

。。。。这不就是线段树的区间更新单点操作嘛。。。。。然后1<=a,b<= 10^9...也就是不能线段树直接来了

思路： 把每次输入的l 存到一个有序集合，每次输入的r存到一个有序集合

然后对于每次查询的点X。我们只需要看大于该点X的l有多少个，大于等于该点X的r有多少个，然后用r的个数减去l的个数。

就得到该点被覆盖的次数了...也就是该点的值

实现：

1、每次插入完,储存数据的结构必须是有序的(这里我用set.logn..)

2、每次查询的时候，用二分在有序结构中分别找到大于x的l和r （二分logn）

3、对于得到的大于X的l，和r,  还得知道他们在该有序结构中的排名...才能用总数-排名得到 大于X的个数...这里我用treap logn查询某个数的排名 

复杂度就是 （n*logn）..

然而其实对 步骤 1 2 3其实直接用一个平衡树或者伸展树实现就好了....我等渣渣只好用set+treap狡猾地实现了。。。

代码在最后

----------------------------------------------------------------------------

另外一种做法是离线做法，对 点离散化  （比第一种稍快）

先把所有的操作输入储存，把所有查询的点 先离散化 排好序，（nlogn）

然后开始按输入顺序 执行

 操作1：  每次给区间 【a,b】加1的时候，先在 <离散化+排序好的> 查询点 的数组中二分找到 第一个大于等于a的下标X和第一个大于b的下标Y 然后用树状数组 给 【x,y】加1（logn）  

操作2：由于操作1已经实现了，直接在树状数组总取 查询点对应离散化后的点的值即可

set+treap代码：

//treap
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <iostream>
#include <queue>
#include <map>
#include <set>
#include <vector>
using namespace std; 
#include <iostream>
using namespace std; 
#define MAXN 200010
struct data{
    int l,r,v,size,rnd,w;
};
 
class tp
{
public: 
    int n,size,root,ans;
    tp()
    {
        n=size=root=ans=0;
    }
    data tr[MAXN];
    void update(int k)//更新结点信息
    {
        tr[k].size=tr[tr[k].l].size+tr[tr[k].r].size+tr[k].w;
    }
    void rturn(int &k)
    {
        int t=tr[k].l;tr[k].l=tr[t].r;tr[t].r=k;
        tr[t].size=tr[k].size;update(k);k=t;
    }
    void lturn(int &k)
    {
        int t=tr[k].r;tr[k].r=tr[t].l;tr[t].l=k;
        tr[t].size=tr[k].size;update(k);k=t;
    }
    void insert(int &k,int x)
    {
        if(k==0)
        {
            size++;k=size;
            tr[k].size=tr[k].w=1;tr[k].v=x;tr[k].rnd=rand();
            return;
        }
        tr[k].size++;
        if(tr[k].v==x)tr[k].w++;//每个结点顺便记录下与该节点相同值的数的个数
        else if(x>tr[k].v)
        {
            insert(tr[k].r,x);
            if(tr[tr[k].r].rnd<tr[k].rnd)lturn(k);//维护堆性质
        }
        else 
        {
            insert(tr[k].l,x);
            if(tr[tr[k].l].rnd<tr[k].rnd)rturn(k);
        } 
    }
    void del(int &k,int x)
    {
        if(k==0)return; 
        if(tr[k].v==x)
        {
            if(tr[k].w>1)
            {
                tr[k].w--;tr[k].size--;return;//若不止相同值的个数有多个，删去一个
            }
            if(tr[k].l*tr[k].r==0)k=tr[k].l+tr[k].r;//有一个儿子为空
            else if(tr[tr[k].l].rnd<tr[tr[k].r].rnd)
                rturn(k),del(k,x);
            else lturn(k),del(k,x);
        }
        else if(x>tr[k].v)
            tr[k].size--,del(tr[k].r,x);
        else tr[k].size--,del(tr[k].l,x);
    }
    int query_rank(int k,int x)
    {
        if(k==0)return 0;
        if(tr[k].v==x)return tr[tr[k].l].size+1;
        else if(x>tr[k].v)
            return tr[tr[k].l].size+tr[k].w+query_rank(tr[k].r,x);
        else return query_rank(tr[k].l,x);
    }
    int query_num(int k,int x)
    {
        if(k==0)return 0;
        if(x<=tr[tr[k].l].size)
            return query_num(tr[k].l,x);
        else if(x>tr[tr[k].l].size+tr[k].w)
            return query_num(tr[k].r,x-tr[tr[k].l].size-tr[k].w);
        else return tr[k].v;
    }
    void query_pro(int k,int x)
    {
        if(k==0)return;
        if(tr[k].v<x)
        {
            ans=k;query_pro(tr[k].r,x);
        }
        else query_pro(tr[k].l,x);
    }
    void query_sub(int k,int x)
    {
        if(k==0)return;
        if(tr[k].v>x)
        {
            ans=k;query_sub(tr[k].l,x);
        }
        else query_sub(tr[k].r,x);
    }
}; 

    tp sp1,sp2;
multiset<int> q1,q2;
multiset<int>::iterator t1,t2;
int main()
{ 
    freopen( "environment.in","r",stdin );  //scanf 从1.txt输入
    freopen( "environment.out","w",stdout );  //printf输出到1.tx
    int n,i,op;
    int aa,bb;
    scanf("%d", &n); 
    int root;
    int d=0;
    int ddd=1;
    int cnt=0;
    for(  i = 1; i <= n; i++) 
    {
        scanf("%d",&op);
        if (op==1)
        {
            scanf("%d%d",&aa,&bb);
            aa=aa+d;
            bb=bb+d;
            sp1.insert(sp1.root,aa);
            sp2.insert(sp2.root,bb);
            q1.insert(aa); 
               q2.insert(bb); 
            cnt++;
            
            
        }
        else
        { 

             int t3,t4;
               scanf("%d",&aa);
            t1=q1.upper_bound(aa);
            t2=q2.lower_bound(aa);
            if (t1==q1.end()) 
                t3=cnt+1;
            else
                t3=sp1.query_rank(sp1.root,*t1);
            if (t2==q2.end())
                t4=cnt+1;
            else
                t4=sp2.query_rank(sp2.root,*t2);
 
            d=(1+cnt-t4)- (1+cnt-t3);
            printf("%d\n",d);
            
            
            
            
            
        }
    }
    
    
    return 0;
}

离散化做法 ：

 
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <iostream>
#include <queue>
#include <map>
#include <set>
#include <vector>
using namespace std; 
#include <iostream>
using namespace std; 
#define MAXN 200010
int n;

int tree[MAXN];
 struct node
{
	int x,num;		//把原始数据 的值 与原始序号储存
	bool operator <(const node& b )const
	{return x<b.x;}
	bool operator >(const node& b )const
	{return x>b.x;}
 		bool operator == (const node& b )const
	{return x==b.x;}
	node(){}
	node(int i,int k){x=i;num=k;}

};
int cmp(node a,node b)
{
	return a.x<b.x;			//把原始数据按值排序，
}


int max(int a,int b )
{
	if (a<b)return b;return a;
}

inline  int lowbit(int x)
{
	return x&-x;
}
void add(int x,int value)
{
	for (int i=x;i<=n;i=i+lowbit(i))
	{
		tree[i]+=value;
	}
}
int get(int x)
{
	int sum=0;
	for (int i=x;i;i-=lowbit(i))
	{
		sum+=tree[i];
	}
	return sum;
}
struct op
{
	int p;
	int a,b;

};
op ope[MAXN]; 
node  point[MAXN]; 
set<int> vis;
int main()
{
 	freopen( "environment.in","r",stdin );  //scanf 从1.txt输入
   freopen( "environment.out","w",stdout );  //printf输出到1.tx
 	int i,aa,bb,j;
	int op;
	scanf("%d",&n);
	int cnt=0;
	for (i=1;i<=n;i++)
	{
	 
		  scanf("%d",&op);
        if (op==1)
        {
            scanf("%d%d",&aa,&bb);
			ope[i].p=1;
			ope[i].a=aa;
			ope[i].b=bb;
			
        }
		else
		{
			scanf("%d",&aa);
			ope[i].p=2;
			ope[i].a=aa;
			if (vis.find(aa)!=vis.end()) continue;
			vis.insert(aa);
			point[++cnt].x=aa;
			point[cnt].num=cnt; 
		
		} 
	}
	sort(point+1,point+1+cnt,cmp);				//对原始数据按值排升序
  
	int d=0;
	for (i=1;i<=n;i++)
	{
		if (ope[i].p==1)
		{
			int l=d+ope[i].a;
			int r=d+ope[i].b;
			int lp=lower_bound(point+1,point+1+cnt,node(l,1))-point;
			int rp=upper_bound(point+1,point+1+cnt,node(r,1))-point;
			add(lp,1);
			add(rp,-1);


		}
		else
		{
			int position=lower_bound(point+1,point+cnt+1,node(ope[i].a,1))-point;
		 

			printf("%d\n",d=get(position));

		}
	}



  
    
    
    return 0;
}