zoukankan      html  css  js  c++  java
  • 神奇的分块算法(学习笔记)

    分块:通过适当的划分,把数据分成一个一个的"块".

    处理时,如果整个"块"都在操作范围内,直接对"块"进行操作,而如果只有"块"的一部分需要操作,则直接暴力处理.称之为"大段维护,局部朴素(暴力)"

    如何分块影响到整道题目的时间效率.分块分得好,程序跑的飞快.分得不好,与暴力算法相差无几.如何分块能够使时间效率最低 是可以根据程序来计算的,蒟蒻数学太渣,不会算.所以大多数情况下通常是划分成(sqrt(n))块,时间效率往往是(nsqrt(n)),故还有人说它是神奇的(nsqrt(n))算法.

    很多题目中,我们只是借助分块的思想,对数据划分成"块"后,便于处理.所以分块就像离散化一样,往往是一个预处理过程.比如莫队就是基于分块的预处理.

    哈希冲突

    长度为n的序列,m次操作.操作有询问和修改两种.

    询问:模x 等于y的下标上的权值 的总和.

    修改:将下标x的权值修改为y.

    本题可以美妙的暴力求解,但正解是分块.我们就来谈谈分块.

    我们要求的答案实际上就是:

    for(int i=y;i<=n;i+=x)
    	ans+=val[i];
    

    但这样显然会超时,因为当模数x=1时,此算法就是(n^2)算法(实际上暴力就是卡在这一个点上),当模数x越小时,就越接近(n^2).(n一定时,模数x越大,循环次数就越少)

    考虑如何优化?既然"当模数x越小时,就越接近(n^2)",为什么不预处理出模数很小的时候的答案呢,这个"小"是如何界定的呢?不如就以(sqrt(n))为分界值吧(好随意).

    当模数在(1)~(sqrt(n))范围内时,直接用一个f的二维数组记录答案.(f[x][y])表示模x时等于y的下标上的权值的总和.就像这样:

    for(int i=1;i<=n;i++)
    	for(int j=1;j<=sqrt(n);j++)
         	f[j][i%j]+=val[i];
    

    于是我们通过美妙的(nsqrt(n))预处理出了当模数x小于等于(nsqrt(n))时的答案,则当模数x大于(nsqrt(n))时,就直接像最上面那样暴力求解即可.

    再来考虑修改操作,修改时我们只要维护当模数x小于等于(nsqrt(n))时的答案即可.

    for(int i=1;i<=unit;i++){
    	f[i][x%i]+=y-val[x];
    }
    val[x]=y;
    

    鉴于上面分析得这么详细,把下面代码的核心全都挖出来讲了,所以就不注释代码了.

    int n,m,unit;
    int val[150005],f[2005][2005];
    int main(){
        n=read();m=read();
        unit=sqrt(n);
        for(int i=1;i<=n;i++){
        	val[i]=read();
        	for(int j=1;j<=unit;j++){
    	    	f[j][i%j]+=val[i];
        	}
        }
        while(m--){
        	char op;cin>>op;
        	int x=read(),y=read();
        	if(op=='C'){
    	    	for(int i=1;i<=unit;i++){
    				f[i][x%i]+=y-val[x];
    	    	}
    	    	val[x]=y;
        	}
        	else{
    	    	if(x<=unit){
    				printf("%d
    ",f[x][y]);
    				continue;
    	    	}
    	    	else{
    				int ans=0;
    				for(int i=y;i<=n;i+=x){
    		    		ans+=val[i];
    				}
    				printf("%d
    ",ans);
    	    	}
        	}
        }
        return 0;
    }
    
    

    教主的魔法

    长度为n的序列,Q次操作.

    修改:把序列([l,r])之间的每个数加上(val);

    询问:查询序列([l,r])之间大于等于(val)的数的个数.

    此题极像线段树的板子题,但仔细想想,线段树统计区间范围内大于等于(val)的数的个数很吃力,那就还是考虑分块.

    int n,Q,unit;
    int a[1000005],c[1000005];
    struct kuai{
        int l,r,add;
    }b[10005];
    //结构体记录每一个"块"的左右端点位置和增加标记add
    //这个add就相当于的线段树区间修改中的延迟标记
    void change(int l,int r,int val){
        for(int i=1;i<=unit;i++){
    		if(l<=b[i].l&&r>=b[i].r)
            	b[i].add+=val;
    //当这一"块"全都位于修改范围内时,add标记
    		else if(l<=b[i].l&&r<=b[i].r){
    	    	for(int j=b[i].l;j<=b[i].r;j++){
    				c[j]=a[j]+b[i].add;
    				if(j>=b[i].l&&j<=r)
                    	c[j]+=val;
    	    	}
    	    	sort(c+b[i].l,c+b[i].r+1);
    		}
    		else if(l>=b[i].l&&r>=b[i].r){
    	    	for(int j=b[i].l;j<=b[i].r;j++){
    				c[j]=a[j]+b[i].add;
    				if(j>=l&&j<=b[i].r)
                    	c[j]+=val;
    	    	}
    	    	sort(c+b[i].l,c+b[i].r+1);
    		}
    //当这一"块"只有部分在修改范围内时,直接暴力地处理
    //每处理完一个"块",仍要保证"块"内的单调性
        }
    }
    int erfen(int num,int val){
        if(c[b[num].l]+b[num].add>=val)
        	return b[num].r-b[num].l+1;
    //这一"块"最小的值都大于等于val
    //则整个"块"都会对答案产生贡献
        else if(c[b[num].r]+b[num].add<val)
        	return 0;
    //这一"块"最大的值都小于val,则全都不会产生贡献.
        else{
    		int l=b[num].l,r=b[num].r,mid,ans;
    		while(l<=r){
    	    	mid=(l+r)>>1;
    	    	if(c[mid]+b[num].add>=val){
    				ans=mid;
    				r=mid-1;
    	    	}
    	    	else l=mid+1;
    		}
    		return b[num].r-ans+1;
        }
    //其余情况都要二分查找
    }
    void query(int l,int r,int val){
        int ans=0;
        for(int i=1;i<=unit;i++){
    		if(l<=b[i].l&&r>=b[i].r)
        		ans+=erfen(i,val);
    //当这一"块"全都位于查询范围内时,对整个"块"二分查找
    		else if(l<=b[i].l&&r<=b[i].r){
    	    	for(int j=b[i].l;j<=r;j++)
    				if((c[j]+b[i].add)>=val)
                    	ans++;
    		}
    		else if(l>=b[i].l&&r>=b[i].r){
    	    	for(int j=l;j<=b[i].r;j++)
    				if((c[j]+b[i].add)>=val)
                    	ans++;
    		}
    //当这一"块"只有部分在查询范围内时,直接暴力地处理
        }
        printf("%d
    ",ans);
    }
    int main(){
        n=read();Q=read();
        unit=sqrt(n);
        for(int i=1;i<=n;i++){
    		a[i]=read();
    		c[i]=a[i];
        }
        for(int i=1;i<=unit;i++){
    		b[i].l=(i-1)*unit+1;
    		b[i].r=i*unit;
        }
        if(b[unit].r!=n){
        	unit++;
            b[unit].l=b[unit-1].r+1;
            b[unit].r=n;
        }
    //这个for和if是在预处理每一"块"的左右端点的位置
        for(int i=1;i<=unit;i++)
        	sort(c+b[i].l,c+b[i].r+1);
    //为了快速查询,维护每一块内的数值单调递增
        while(Q--){
    		char op;cin>>op;
    		int l=read(),r=read(),val=read();
    		if(op=='M'){change(l,r,val);}
    		else{query(l,r,val);}
        }
        return 0;
    }
    
    
  • 相关阅读:
    servlet ; basepath ; sendredirected ;
    4.18 一个阶段
    服务器强迫患者 ;软件试用狂人
    html ; css ; javascript ; json ;
    评审意见
    Beta版使用说明书
    内测版发布反思问题总结
    团队项目第二阶段冲刺第十天
    团队项目第二阶段冲刺第九天
    团队项目第二阶段冲刺第八天
  • 原文地址:https://www.cnblogs.com/PPXppx/p/10314172.html
Copyright © 2011-2022 走看看