• 扫描线+离散化+线段树


    给出题目!
    题目界面
    那么,大家一看一般是一脸蒙蔽
    这里写图片描述

    因为这确实听刁钻,许多人不会打二维线段树,却一直在想线段树怎么打,可悲(大佬:花了5分钟打出二维线段树,好难!),那摸,大家,这道题怎么做?

    接下来会涉及到离散化与线段树,请自学,抱歉⊙﹏⊙

    那么,这道题呢,重要的是扫描线(如图):
    这里写图片描述

    那一根根蓝或红线就叫线(矩阵左右的线为红,上下为蓝,为什么这样分色,后面讲),每根线其实都是某个矩阵上的一条边。(注意,扫描线比较适合用于在矩阵的每条边严格与X轴或Y轴平行或重合的矩阵问题上)

    现在,把与X轴平行的线和与Y轴平行分开来。

    同时,我们
    规定,代表矩阵下面和左边的边,为入边,这些线权值为1,同时规定矩阵上面和右边的边,为出边,这些线权值为-1,那么代表一个矩阵的四根线权值加起来就为1了!

    那么,我们再定一条更厉害的动态线,叫扫描线,我们每次只用扫描线处理一种颜色的线,先扫红色:
    这里写图片描述

    这条扫描线上也被Y坐标分成一个个小格,每个格子一开始值为0。
    每经过一条红线,就将这条红线与扫描线重叠部分加上这条线的权值。
    如图:
    这里写图片描述
    现在,前面的权值就有用了(扫描线全部扫完后身上所有的格的值都为0)

    当扫描线扫过出边的时候,就把入边的值给抵消了!

    这里写图片描述

    然后在将蓝线扫一遍就可以将全局的线用两次扫描就扫完了!

    那么,怎么统计答案呢?
    暴力的话只需要统计当这个格子里加为1和减为0的时,给答案加上这个格子离散前的长度(离散后长度为1)。(想想为什么,很关键!)
    但是,这样暴力仍然为O(n^2)

    于是,我们用线段树让他变为O(nlogn)

    许多人就开始想lazy使时间变短,但是,其实,根本没有lazy,只不过统计答案的方式与暴力不同而已!

    给出代码(离散化可以根据个人爱好改变):

    #include<cstdio>
    #include<cstring>
    #include<cstdlib>
    #include<algorithm>
    using  namespace  std;
    
    const  int  cc=300000;//范围 
    
    struct  ndoe
    {
    	int  l,r,lc,rc,c,ss;//ss代表当前这个范围被完整覆盖了几次 
    }a[cc];int  len;//线段树 
    
    struct  caozuo
    {
    	int  x,l,r,k;//l与r为范围,k为权值,x为用于排列的坐标
    }tot1[cc],tot2[cc];//记录线的信息,tot1为蓝线,tot2为红线 
    
    struct  LSnode
    {
    	int  x,y;
    }A[cc],B[cc];//离散值 
    
    int  n,kk1,kk2,ys1[cc],ys2[cc];
    //ys1[i]代表离散后编号为i的点与离散后编号为0的点离散前的长度是多少?ys2也一样。
    bool  cmp1(LSnode  x,LSnode  y){return  x.x<y.x;}//离散化的排列 
    
    bool  cmp2(caozuo  x,caozuo  y){return  x.x!=y.x?x.x<y.x:x.k>y.k;}//将线按顺序排起来,一个个改变扫描线的值,来模拟扫描线扫过去的场景 
    
    void  bt(int  l,int  r)
    {
    	len++;int  now=len;
    	a[now].l=l;a[now].r=r;a[now].c=a[now].lc=a[now].rc=0;
    	if(l+1<r)//因为扫描线上每个格子长度为1,只有大于1才可以申请左右儿子来帮忙 
    	{
    		int  mid=(l+r)/2;
    		a[now].lc=len+1;bt(l,mid);
    		a[now].rc=len+1;bt(mid,r);//左儿子与右儿子 
    	}
    }//建树 
    
    void  update(int  x)
    {
    	if(a[x].ss!=0)a[x].c=ys1[a[x].r]-ys1[a[x].l];//离散前的长度
    	else  a[x].c=a[a[x].lc].c+a[a[x].rc].c;//不行就继承
    }//统计答案的重点,注意,不用+=
    
    void  change(int  now,int  l,int  r,int  k)
    {
    	if(a[now].l==l  &&  a[now].r==r){a[now].ss+=k;update(now);return  ;}//完全覆盖直接统计 
    	int  lc=a[now].lc,rc=a[now].rc,mid=(a[now].l+a[now].r)/2;
    	if(r<=mid)change(lc,l,r,k);
    	else  if(mid<=l)change(rc,l,r,k);
    	else  change(lc,l,mid,k),change(rc,mid,r,k);//否则只能扔给左右儿子处理 
    	//因为mid代表的坐标的是,所以不需要加一 
    	update(now);//统计 
    }
    
    int  main()
    {
    	scanf("%d",&n);
    	for(int  i=1;i<=n;i++)
    	{
    		scanf("%d%d%d%d",&A[i*2-1].x,&B[i*2-1].x,&A[i*2].x,&B[i*2].x);
    		
    		tot1[i*2-1].x=B[i*2-1].x;tot1[i*2].x=B[i*2].x;
    		tot2[i*2-1].x=A[i*2-1].x;tot2[i*2].x=A[i*2].x;//给每条线的坐标(为什么只给一个,因为另外的一个坐标是当作范围来用的) 
    		
    		tot1[i*2-1].k=tot2[i*2-1].k=1;tot1[i*2].k=tot2[i*2].k=-1;//出边与入边 
    		
    		A[i*2-1].y=B[i*2-1].y=i*2-1;A[i*2].y=B[i*2].y=i*2;//离散化,A为tot1离散范围,B为tot2离散。 
    	}
    	sort(A+1,A+n*2+1,cmp1);sort(B+1,B+n*2+1,cmp1);//排序 
    	A[0].x=A[1].x-1,B[0].x=B[1].x-1; 
    	
    	for(int  i=1;i<=n*2;i++)
    	{
    		if(A[i].x!=A[i-1].x)
    		{
    			kk1++;
    			ys1[kk1]=ys1[kk1-1]+A[i].x-A[i-1].x;
    		}
    		
    		if(B[i].x!=B[i-1].x)
    		{
    			kk2++;
    			ys2[kk2]=ys2[kk2-1]+B[i].x-B[i-1].x;//前缀和方便后面处理 
    		}
    		
    		int  kkk_c1=A[i].y,kkk_c2=B[i].y;//分清这是范围内的l还是r 
    		
    		if(kkk_c1%2==1)tot1[kkk_c1].l=tot1[kkk_c1+1].l=kk1;
    		else  tot1[kkk_c1].r=tot1[kkk_c1-1].r=kk1;
    		
    		if(kkk_c2%2==1)tot2[kkk_c2].l=tot2[kkk_c2+1].l=kk2;
    		else  tot2[kkk_c2].r=tot2[kkk_c2-1].r=kk2;
    	}
    	
    	sort(tot1+1,tot1+2*n+1,cmp2);sort(tot2+1,tot2+2*n+1,cmp2);//将线扫一遍 
    	
    	int  ans=0,lastt=0;//关键! 
    	
    	len=0;bt(1,kk1);//建树 
    	for(int  i=1;i<=n*2;i++)
    	{
    		lastt=a[1].c;//统计上次的答案 
    		if(tot1[i].l!=tot1[i].r)change(1,tot1[i].l,tot1[i].r,tot1[i].k);//扫蓝线 
    		ans+=abs(a[1].c-lastt);//加个abs因为出边会使答案变小,ans只记录这次该变了什么 
    	}
    	
    	for(int  i=1;i<=kk2;i++)ys1[i]=ys2[i];//其实可以搞两颗线段时,为了简洁,只好这样 
    	
    	len=0;bt(1,kk2);//建树 
    	for(int  i=1;i<=n*2;i++)
    	{
    		lastt=a[1].c;//统计上次的答案 
    		if(tot2[i].l!=tot2[i].r)change(1,tot2[i].l,tot2[i].r,tot2[i].k);//扫红线 
    		ans+=abs(a[1].c-lastt);//加个abs因为出边会使答案变小,ans只记录这次该变了什么
    	}
    	printf("%d
    ",ans);//输出 
    	return  0;
    }
    

    大家是不是对

    void  update(int  x)
    {
    	if(a[x].ss!=0)a[x].c=ys1[a[x].r]-ys1[a[x].l];//离散前的长度
    	else  a[x].c=a[a[x].lc].c+a[a[x].rc].c;//不行就继承
    }//统计答案的重点 
    
    ——————————————————————————————————————————————————————————
    
    int  ans=0,lastt=0;//关键! 
    	
    len=0;bt(1,kk1);//建树 
    for(int  i=1;i<=n*2;i++)
    {
    	lastt=a[1].c;//统计上次的答案 
    	if(tot1[i].l!=tot1[i].r)change(1,tot1[i].l,tot1[i].r,tot1[i].k);//扫蓝线 
    	ans+=abs(a[1].c-lastt);//加个abs因为出边会使答案变小,ans只记录这次该变了什么
    }
    
    for(int  i=1;i<=kk2;i++)ys1[i]=ys2[i];//其实可以搞两棵线段时,为了简洁,只好这样 
    
    len=0;bt(1,kk2);//建树 
    for(int  i=1;i<=n*2;i++)
    {
    	lastt=a[1].c;//统计上次的答案 
    	if(tot2[i].l!=tot2[i].r)change(1,tot2[i].l,tot2[i].r,tot2[i].k);//扫红线 
    	ans+=abs(a[1].c-lastt);//加个abs因为出边会使答案变小,ans只记录这次该变了什么
    }
    

    不理解?
    线段树里的c代表这个线段树节点所管理的扫描线范围里有值的格子的长度(长度为离散前的长度)。
    那么,如果父亲节点的ss!=0并且儿子节点的ss!=0,不就重复了吗,但是,我们仍然只算父亲节点的区间,因为他包括了儿子节点的范围,所以才加了个else。

    因为有$$ans+=abs(a[1].c-lastt);$$这一句,和

    void  update(int  x)
    {
    	if(a[x].ss!=0)a[x].c=ys1[a[x].r]-ys1[a[x].l];//离散前的长度
    	else  a[x].c=a[a[x].lc].c+a[a[x].rc].c;//不行就继承
    }//统计答案的重点
    

    所以,我们仔细观察能发现一下结论。

    1. 如果一个扫描线的区间多次经过入边,c值不变。
    2. 由于lastt记录了上一次的根节点的值,所以没变的c值不会被ans再次加入。
    3. 若某个扫描线的区间被出边更改为0,继承左右儿子的c值后,由于lastt值上一次几录了他是整个区间都被覆盖的c值,这一次利用abs可以加到这次操作中由有值被减为0的区间值。
    4. 一次更改中,所有区间不会出现那边减这边加的情况,顶多某个加,或某个减(线的权值要么为正,要么为服,所以会出现这种情况!)
    5. ss值一直为非负数!

    那么,根据1跟2结论,重复计算不会出现,根据3跟4结论,出边也有可能有影响。

    那么,大家会发现:
    这里写图片描述
    这张图上有一条出边与入边重合了,如果不判断的话可能会出现中间这一条线的长度被计算两次,那么我们将入边优先,出边靠后就可以解决了!

    bool  cmp2(caozuo  x,caozuo  y){return  x.x!=y.x?x.x<y.x:x.k>y.k;}
    //x值不一样按先后排序,不一样按出入边排序,但因为入边权值大于出边,所以可以这样写
    

    由于计算这两条线的时候这个区间的ss值一直大于0,所以c值也不变,ans值也不会记录。

    罗里吧嗦这么一大堆,那么这个为什么对?,因为ans只在某个区间的ss值在变化为0或1时记录答案,根本与暴力也是十分像的!
    ( ·_·逃

    这里写图片描述

  • 相关阅读:
    POJ 1811 Prime Test (Rabin-Miller强伪素数测试 和Pollard-rho 因数分解)
    POJ 1200 Crazy Search (哈希)
    POJ 1061 青蛙的约会 (扩展欧几里得算法)
    POJ 1035 Spell checker (模拟)
    hud 2554 N对数的排列问题 (规律)
    HDU 2522 A simple problem (模拟)
    Python环境配置及项目建立
    IDEA通过MyBatis generator生成数据库表的对象
    复制、粘贴、剪切 操作
    下载歌曲(以QQ音乐为例)
  • 原文地址:https://www.cnblogs.com/zhangjianjunab/p/9694669.html
Copyright © 2020-2023  润新知