2021-05-19 「分块」数列分块入门1 – 9

最新推荐文章于 2021-10-06 22:14:52 发布
最新推荐文章于 2021-10-06 22:14:52 发布
阅读量118 收藏
点赞数
分类专栏： 每日三题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46064382/article/details/117019512
版权

数列分块入门 1

1.题意：

区间加法，单点查值

2.题解：

死活不知道开始为什么超时

3.ac代码：
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
const int N = 50000 + 10;
int a[N];
int n, m;
int st[N], ed[N], sz[N], sum[N], bel[N], mark[N];
inline void init(int n) { //分块
    int  sq = sqrt(n);

    for (int i = 1; i <= sq; i++) {
        st[i] = sq * (i - 1) + 1;
        ed[i] = sq * i;
        sz[i] = ed[i] - st[i] + 1;
    }

    ed[sq] = n;
    sz[sq] = ed[sq] - st[sq] + 1;

    for (int i = 1; i <= sq; i++) {
        for (int j = st[i]; j <= ed[i]; j++) {
            bel[j] = i;
            //  sum[i]+=a[j];
        }

    }
}
inline void change(int l, int r, int d) { //区间修改,加上一个数
    if (bel[l] == bel[r]) {
        for (int i = l; i <= r; i++) {
            a[i] += d;
            //  sum[bel[i]]+=d;
        }
    } else {
        for (int i = l; i <= ed[bel[l]]; i++)
            a[i] += d;

        // sum[bel[l]]+=d*(ed[bel[l]]-l+1);
        for (int i = st[bel[r]]; i <= r; i++)
            a[i] += d;

        //sum[bel[r]]+=d*(r-st[bel[r]]+1);
        for (int i = bel[l] + 1; i < bel[r]; i++)
            mark[i] += d;
    }
}
//ll query(int l,int r){//区间查询
//    ll ans=0;
//    if(bel[l]==bel[r]){
//        for(int i=l;i<=r;i++) ans+=a[i];
//        ans+=mark[bel[l]]*(r-l+1);
//    }else{
//        for(int i=l;i<=ed[bel[l]];i++) ans+=a[i];
//        ans+=mark[bel[l]]*(ed[bel[l]]-l+1);
//        for(int i=st[bel[r]];i<=r;i++) ans+=a[i];
//        ans+=mark[bel[r]]*(r-st[bel[r]]+1);
//        for(int i=bel[l]+1;i<bel[r];i++) ans+=sum[i]+mark[i]*sz[i];
//
//    }
//}

int main() {
    scanf("%d", &n);

    for (int i = 1; i <= n; i++)
        scanf("%d", &a[i]);

    int l, r, op;
    int c;
    init(n);

    for (int i = 1; i <= n; i++) {
        scanf("%d%d%d%d", &op, &l, &r, &c);

        if (op == 0) {
            change(l, r, c);
        } else {
            printf("%d\n", a[r] + mark[bel[r]]);
        }
    }
}

数列分块入门 2

1.题意：

区间加法，询问区间内小于某个值 x的元素个数。

2.题解：

!!!快哭了啊啊啊啊啊啊，我终于知道我错哪了，卡了我快俩小时md

3.ac代码：
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
const int N = 50000 + 10;
int a[N];
int n, m;
int st[N], ed[N], sz[N], sum[N], bel[N], mark[N];
vector<int> v[N];
inline void init(int n) { //分块
    int  sq = sqrt(n);

    for (int i = 1; i <= sq; i++) {
        st[i] = sq * (i - 1) + 1;
        ed[i] = sq * i;
        sz[i] = ed[i] - st[i] + 1;      
    }

    ed[sq] = n;
    sz[sq] = ed[sq] - st[sq] + 1;

    for (int i = 1; i <= sq; i++) {
        for (int j = st[i]; j <= ed[i]; j++) {
            bel[j] = i;
            v[i].push_back(a[j]);
             sum[i]+=a[j];
        }
        sort(v[i].begin(),v[i].end());
    }
    
}
void reset(int i){
	
	for(int j=0;j<=sz[i];j++){
		v[i][j]=a[st[i]+j];
	}
	sort(v[i].begin(),v[i].end());
}
inline void change(int l, int r, int d) { //区间修改,加上一个数
    if (bel[l] == bel[r]) {
        for (int i = l; i <= r; i++) {
            a[i] += d;
        }
        reset(bel[l]);
       
    } else {
        for (int i = l; i <= ed[bel[l]]; i++)
            a[i] += d;
        reset(bel[l]);
        
        for (int i = st[bel[r]]; i <= r; i++)
            a[i] += d;
        reset(bel[r]);
        
        for (int i = bel[l] + 1; i < bel[r]; i++)
            mark[i] += d;
    }
}
int query(int l,int r,int c){//区间查询,小于c的个数
    int ans=0;
    if(bel[l]==bel[r]){
        for(int i=l;i<=r;i++){
            if(a[i]+mark[bel[i]]<c*c) ans++;
        }
    }else{
        for(int i=l;i<=ed[bel[l]];i++){
            if(a[i]+mark[bel[l]]<c*c) ans++;
        } 
       
        for(int i=st[bel[r]];i<=r;i++){
            if(a[i]+mark[bel[r]]<c*c) ans++;
        } 
         
        for(int i=bel[l]+1;i<bel[r];i++){
            ans+=lower_bound(v[i].begin(), v[i].end(),c*c-mark[i])-v[i].begin();//!!!mark【i】!!不是mark【bel【i】】
        }

    }
    return ans; 
}

int main() {
    cin>>n;

    for (int i = 1; i <= n; i++)
        cin>>a[i];

    int l, r, op;
    ll c;
    init(n);

    for (int i = 1; i <= n; i++) {
        cin>>op>>l>>r>>c;

        if (op == 0) {
            change(l, r, c);
        } else {
           cout<<query(l,r,c)<<endl;
        }
    }
}

数列分块入门 3

1.题意：

区间加法+询区间内比x小的最大元素

2.题解：

在 [first, last) 区域内查找

  • lower_bound(,x) 第一个>=x

   int a[5] = { 1,2,3,4,5 };
    //从 a 数组中找到第一个不小于 3 的元素
    int *p = lower_bound(a, a + 5, 3);

*p=3

  • upper bound(,x) 第一个>x
int a[5] = { 1,2,3,4,5 };
    //从 a 数组中找到第一个大于 3 的元素
    int *p = upper_bound(a, a + 5, 3);

*p = 4

3.ac代码：
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
const int N =1e6 + 10;
int a[N];
int n, m;
int st[N], ed[N], sz[N], sum[N], bel[N], mark[N];
vector<int> v[N];
inline void init(int n) { //分块
    int  sq = sqrt(n);

    for (int i = 1; i <= sq; i++) {
        st[i] = sq * (i - 1) + 1;
        ed[i] = sq * i;
        sz[i] = ed[i] - st[i] + 1;      
    }

    ed[sq] = n;
    sz[sq] = ed[sq] - st[sq] + 1;

    for (int i = 1; i <= sq; i++) {
        for (int j = st[i]; j <= ed[i]; j++) {
            bel[j] = i;
            v[i].push_back(a[j]);
             sum[i]+=a[j];
        }
        sort(v[i].begin(),v[i].end());
    }
    
}
void reset(int i){
	
	for(int j=0;j<=sz[i];j++){
		v[i][j]=a[st[i]+j];
	}
	sort(v[i].begin(),v[i].end());
}
inline void change(int l, int r, int d) { //区间修改,加上一个数
    if (bel[l] == bel[r]) {
        for (int i = l; i <= r; i++) {
            a[i] += d;
        }
        reset(bel[l]);
       
    } else {
        for (int i = l; i <= ed[bel[l]]; i++)
            a[i] += d;
        reset(bel[l]);
        
        for (int i = st[bel[r]]; i <= r; i++)
            a[i] += d;
        reset(bel[r]);
        
        for (int i = bel[l] + 1; i < bel[r]; i++)
            mark[i] += d;
    }
}
int query1(int l,int r,int c){//区间查询,小于c的个数
    int ans=0;
    if(bel[l]==bel[r]){
        for(int i=l;i<=r;i++){
            if(a[i]+mark[bel[i]]<c*c) ans++;
        }
    }else{
        for(int i=l;i<=ed[bel[l]];i++){
            if(a[i]+mark[bel[l]]<c*c) ans++;
        } 
       
        for(int i=st[bel[r]];i<=r;i++){
            if(a[i]+mark[bel[r]]<c*c) ans++;
        } 
         
        for(int i=bel[l]+1;i<bel[r];i++){
            ans+=lower_bound(v[i].begin(), v[i].end(),c*c-mark[i])-v[i].begin();
        }

    }
    return ans; 
}
int query2(int l,int r,int c){//查询区间内比x小的最大元素 
    int ans=-1;
    if(bel[l]==bel[r]){
        for(int i=l;i<=r;i++){
            if(a[i]+mark[bel[i]]<c) ans=max(ans,a[i]+mark[bel[i]]); 
        }
    }else{
        for(int i=l;i<=ed[bel[l]];i++){
            if(a[i]+mark[bel[l]]<c) ans=max(ans,a[i]+mark[bel[l]]); 
        } 
       
        for(int i=st[bel[r]];i<=r;i++){
            if(a[i]+mark[bel[r]]<c) ans=max(ans,a[i]+mark[bel[r]]); 
        } 
         
        for(int i=bel[l]+1;i<bel[r];i++){
        	int t=lower_bound(v[i].begin(), v[i].end(),c-mark[i])-v[i].begin();
        	if(t){
        		ans=max(ans,v[i][t-1]+mark[i]);
			}
        }

    }
    return ans; 
}

int main() {
    cin>>n;

    for (int i = 1; i <= n; i++)
        cin>>a[i];

    int l, r, op;
    ll c;
    init(n);

    for (int i = 1; i <= n; i++) {
        cin>>op>>l>>r>>c;

        if (op == 0) {
            change(l, r, c);
        } else {
           cout<<query2(l,r,c)<<endl;
        }
    }
}

数列分块入门 4

1.题意：

区间加法，区间求和

2.题解：

散块暴力，整块求和，求整块和时要把标记乘上块大小，同时记得i表示块th

3.ac代码：
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
const int N =1e6 + 10;
int a[N];
int n, m;
int st[N], ed[N], sz[N], sum[N], bel[N], mark[N];
vector<int> v[N];
inline void init(int n) { //分块
    int  sq = sqrt(n);

    for (int i = 1; i <= sq; i++) {
        st[i] = sq * (i - 1) + 1;
        ed[i] = sq * i;
        sz[i] = ed[i] - st[i] + 1;  
		    
    }

    ed[sq] = n;
    sz[sq] = ed[sq] - st[sq] + 1;

    for (int i = 1; i <= sq; i++) {
        for (int j = st[i]; j <= ed[i]; j++) {
            bel[j] = i;
            v[i].push_back(a[j]);
             sum[i]+=a[j];
        }
        sort(v[i].begin(),v[i].end());
    }
    
}
void reset(int i){
	
	for(int j=0;j<=sz[i];j++){
		v[i][j]=a[st[i]+j];
	}
	sort(v[i].begin(),v[i].end());
}
inline void change(int l, int r, int d) { //区间修改,加上一个数
    if (bel[l] == bel[r]) {
        for (int i = l; i <= r; i++) {
            a[i] += d;
            sum[bel[i]]+=d;
        }
        reset(bel[l]);
       
    } else {
        for (int i = l; i <= ed[bel[l]]; i++)
            a[i] += d,sum[bel[i]]+=d;
        reset(bel[l]);
        
        for (int i = st[bel[r]]; i <= r; i++)
            a[i] += d,sum[bel[i]]+=d;
        reset(bel[r]);
        
        for (int i = bel[l] + 1; i < bel[r]; i++)
            mark[i] += d;
    }
}
int query1(int l,int r,int c){//区间查询,小于c的个数
    int ans=0;
    if(bel[l]==bel[r]){
        for(int i=l;i<=r;i++){
            if(a[i]+mark[bel[i]]<c*c) ans++;
        }
    }else{
        for(int i=l;i<=ed[bel[l]];i++){
            if(a[i]+mark[bel[l]]<c*c) ans++;
        } 
       
        for(int i=st[bel[r]];i<=r;i++){
            if(a[i]+mark[bel[r]]<c*c) ans++;
        } 
         
        for(int i=bel[l]+1;i<bel[r];i++){
            ans+=lower_bound(v[i].begin(), v[i].end(),c*c-mark[i])-v[i].begin();
        }

    }
    return ans; 
}
int query2(int l,int r,int c){//查询区间内比x小的最大元素 
    int ans=-1;
    if(bel[l]==bel[r]){
        for(int i=l;i<=r;i++){
            if(a[i]+mark[bel[i]]<c) ans=max(ans,a[i]+mark[bel[i]]); 
        }
    }else{
        for(int i=l;i<=ed[bel[l]];i++){
            if(a[i]+mark[bel[l]]<c) ans=max(ans,a[i]+mark[bel[l]]); 
        } 
       
        for(int i=st[bel[r]];i<=r;i++){
            if(a[i]+mark[bel[r]]<c) ans=max(ans,a[i]+mark[bel[r]]); 
        } 
         
        for(int i=bel[l]+1;i<bel[r];i++){
        	int t=lower_bound(v[i].begin(), v[i].end(),c-mark[i])-v[i].begin();
        	if(t){
        		ans=max(ans,v[i][t-1]+mark[i]);
			}
        }

    }
    return ans; 
}
int query(int l,int r,int c){//区间和mod(c+1)
	 int ans=0;
    if(bel[l]==bel[r]){
        for(int i=l;i<=r;i++){
            ans=(a[i]+mark[bel[i]]+ans)%(c+1);
        }
    }else{
        for(int i=l;i<=ed[bel[l]];i++){
            ans=(a[i]+mark[bel[i]]+ans)%(c+1);
        } 
       
        for(int i=st[bel[r]];i<=r;i++){
             ans=(a[i]+mark[bel[i]]+ans)%(c+1);
        } 
         
        for(int i=bel[l]+1;i<bel[r];i++){
             ans=(sum[i]+(ll)sz[i]*mark[i]%(c+1)+ans)%(c+1);
        }

    }
    return ans; 
	
}
int main() {
    cin>>n;

    for (int i = 1; i <= n; i++)
        cin>>a[i];

    int l, r, op;
    ll c;
    init(n);

    for (int i = 1; i <= n; i++) {
        cin>>op>>l>>r>>c;

        if (op == 0) {
            change(l, r, c);
        } else {
           cout<<query(l,r,c)<<endl;
        }
    }
}

数列分块入门 5

1.题意：

区间开方，区间求和

2.题解：

当数字开方到1/0后，再开方数字不变，所以对整块都是0/1的块做标记，即下次不用再处理了，
开方时对零散块暴力，对整块采用标记处理
query依然对零散块暴力求解，对整块直接返回sum

3.ac代码：
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
const int N =1e6 + 10;
int a[N];
int n, m;
int st[N], ed[N], sz[N], sum[N], bel[N], mark[N];
int flag[N];
vector<int> v[N];
inline void init(int n) { //分块
    int  sq = sqrt(n);

    for (int i = 1; i <= sq; i++) {
        st[i] = sq * (i - 1) + 1;
        ed[i] = sq * i;
        sz[i] = ed[i] - st[i] + 1;  
		    
    }

    ed[sq] = n;
    sz[sq] = ed[sq] - st[sq] + 1;

    for (int i = 1; i <= sq; i++) {
        for (int j = st[i]; j <= ed[i]; j++) {
            bel[j] = i;
            v[i].push_back(a[j]);
             sum[i]+=a[j];
        }
        sort(v[i].begin(),v[i].end());
    }
    
}
void reset(int i){
	
	for(int j=0;j<=sz[i];j++){
		v[i][j]=a[st[i]+j];
	}
	sort(v[i].begin(),v[i].end());
}
inline void change(int l, int r, int d) { //区间修改,加上一个数
    if (bel[l] == bel[r]) {
        for (int i = l; i <= r; i++) {
            a[i] += d;
            sum[bel[i]]+=d;
        }
        reset(bel[l]);
       
    } else {
        for (int i = l; i <= ed[bel[l]]; i++)
            a[i] += d,sum[bel[i]]+=d;
        reset(bel[l]);
        
        for (int i = st[bel[r]]; i <= r; i++)
            a[i] += d,sum[bel[i]]+=d;
        reset(bel[r]);
        
        for (int i = bel[l] + 1; i < bel[r]; i++)
            mark[i] += d;
    }
}
int query(int l,int r,int c){//区间和mod(c+1)
	 int ans=0;
    if(bel[l]==bel[r]){
        for(int i=l;i<=r;i++){
            ans=(a[i]+mark[bel[i]]+ans)%(c+1);
        }
    }else{
        for(int i=l;i<=ed[bel[l]];i++){
            ans=(a[i]+mark[bel[i]]+ans)%(c+1);
        } 
       
        for(int i=st[bel[r]];i<=r;i++){
             ans=(a[i]+mark[bel[i]]+ans)%(c+1);
        } 
         
        for(int i=bel[l]+1;i<bel[r];i++){
             ans=(sum[i]+(ll)sz[i]*mark[i]%(c+1)+ans)%(c+1);
        }

    }
    return ans; 
	
}
int query1(int l,int r,int c){//区间查询,小于c的个数
    int ans=0;
    if(bel[l]==bel[r]){
        for(int i=l;i<=r;i++){
            if(a[i]+mark[bel[i]]<c*c) ans++;
        }
    }else{
        for(int i=l;i<=ed[bel[l]];i++){
            if(a[i]+mark[bel[l]]<c*c) ans++;
        } 
       
        for(int i=st[bel[r]];i<=r;i++){
            if(a[i]+mark[bel[r]]<c*c) ans++;
        } 
         
        for(int i=bel[l]+1;i<bel[r];i++){
            ans+=lower_bound(v[i].begin(), v[i].end(),c*c-mark[i])-v[i].begin();
        }

    }
    return ans; 
}
int query2(int l,int r,int c){//查询区间内比x小的最大元素 
    int ans=-1;
    if(bel[l]==bel[r]){
        for(int i=l;i<=r;i++){
            if(a[i]+mark[bel[i]]<c) ans=max(ans,a[i]+mark[bel[i]]); 
        }
    }else{
        for(int i=l;i<=ed[bel[l]];i++){
            if(a[i]+mark[bel[l]]<c) ans=max(ans,a[i]+mark[bel[l]]); 
        } 
       
        for(int i=st[bel[r]];i<=r;i++){
            if(a[i]+mark[bel[r]]<c) ans=max(ans,a[i]+mark[bel[r]]); 
        } 
         
        for(int i=bel[l]+1;i<bel[r];i++){
        	int t=lower_bound(v[i].begin(), v[i].end(),c-mark[i])-v[i].begin();
        	if(t){
        		ans=max(ans,v[i][t-1]+mark[i]);
			}
        }

    }
    return ans; 
}
int query3(int l,int r){//区间开方的求和 
	int ans=0;
    if(bel[l]==bel[r]){
        for(int i=l;i<=r;i++){
            ans+=a[i]+mark[bel[i]];
        }
    }else{
        for(int i=l;i<=ed[bel[l]];i++){
            ans+=a[i]+mark[bel[i]];
        } 
       
        for(int i=st[bel[r]];i<=r;i++){
             ans+=a[i]+mark[bel[i]];
        } 
         
        for(int i=bel[l]+1;i<bel[r];i++){
             ans+=sum[i];
        }

    }
    return ans; 
	
}
void solve_sqrt(int x){//对整块开放后的区间处理sum 
	if(flag[x]) return;//flag!=0即整块不用处理 
	flag[x]=1;
	sum[x]=0;
	for(int i=st[x];i<=ed[x];i++){
		a[i]=sqrt(a[i]);
		sum[x]+=a[i];
		if(a[i]>1) flag[x]=0;
	}
}
void changeSqrt(int l,int r){//区间开方 
	if (bel[l] == bel[r]) {
        for (int i = l; i <= r; i++) {
        	sum[bel[i]]-=a[i];
            a[i] =sqrt(a[i]);
            sum[bel[i]]+=a[i];
        }
      
       
    } else {
        for (int i = l; i <= ed[bel[l]]; i++){
        	sum[bel[i]]-=a[i];
            a[i] =sqrt(a[i]);
            sum[bel[i]]+=a[i];
		}
           
        for (int i = st[bel[r]]; i <= r; i++){
        	sum[bel[i]]-=a[i];
            a[i] =sqrt(a[i]);
            sum[bel[i]]+=a[i];
		}
      
        for (int i = bel[l] + 1; i < bel[r]; i++){
        	solve_sqrt(i);
		}
    }
} 

int main() {
    cin>>n;

    for (int i = 1; i <= n; i++)
        cin>>a[i];

    int l, r, op;
    ll c;
    init(n);

    for (int i = 1; i <= n; i++) {
        cin>>op>>l>>r>>c;

        if (op == 0) {
            changeSqrt(l, r);
        } else {
           cout<<query3(l,r)<<endl;
        }
    }
}

数列分块入门 6

1.题意：

单点插入，单点询问，数据随机生成

2.题解：

关键是rebuild，当增加的数值达到一个块的大小时，就重新分块
开始一直wa是因为，写之前的题里头，把v排序了

3.ac代码：
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
const int N =1e6 + 10;
int a[N];
int n, m;
int sq;
int st[N], ed[N], sz[N], sum[N], bel[N], mark[N];
int flag[N];
vector<int> v[N];
inline void init(int n) { //分块
     sq = sqrt(n);

    for (int i = 1; i <= sq; i++) {
        st[i] = sq * (i - 1) + 1;
        ed[i] = sq * i;
        sz[i] = ed[i] - st[i] + 1;  
		    
    }

    ed[sq] = n;
    sz[sq] = ed[sq] - st[sq] + 1;

    for (int i = 1; i <= sq; i++) {
        for (int j = st[i]; j <= ed[i]; j++) {
            bel[j] = i;
            v[i].push_back(a[j]);
             sum[i]+=a[j];
        }
       // sort(v[i].begin(),v[i].end());
    }
    
}
void reset(int i){
	
	for(int j=0;j<=sz[i];j++){
		v[i][j]=a[st[i]+j];
	}
	sort(v[i].begin(),v[i].end());
}
void rebuild(){//重新分块 
    int k=0;
	for(int i=1;i<=sq;i++){
        for(int j=0;j<v[i].size();j++){
            a[++k]=v[i][j];
        }
        v[i].clear();
    }
    sq=sqrt(k);

    
    for(int i=1;i<=k;i++){
      
        v[(i-1)/sq+1].push_back(a[i]);
    }
} 
inline void change(int l, int r, int d) { //区间修改,加上一个数

    if (bel[l] == bel[r]) {
        for (int i = l; i <= r; i++) {
            a[i] += d;
            sum[bel[i]]+=d;
        }
        reset(bel[l]);
       
    } else {
        for (int i = l; i <= ed[bel[l]]; i++)
            a[i] += d,sum[bel[i]]+=d;
        reset(bel[l]);
        
        for (int i = st[bel[r]]; i <= r; i++)
            a[i] += d,sum[bel[i]]+=d;
        reset(bel[r]);
        
        for (int i = bel[l] + 1; i < bel[r]; i++)
            mark[i] += d;
    }
}
pair<int,int> query4(int x){
	 int i=1;
	while(x>v[i].size()){
        x-=v[i].size();
        i++;
    }
    return make_pair(i,x-1);
}
void insert(int l,int r){//单点插入，在第l个数字前插入r 
	 auto t=query4(l);
    v[t.first].insert(v[t.first].begin()+t.second, r);
   
}
int query(int l,int r,int c){//区间和mod(c+1)
	 int ans=0;
    if(bel[l]==bel[r]){
        for(int i=l;i<=r;i++){
            ans=(a[i]+mark[bel[i]]+ans)%(c+1);
        }
    }else{
        for(int i=l;i<=ed[bel[l]];i++){
            ans=(a[i]+mark[bel[i]]+ans)%(c+1);
        } 
       
        for(int i=st[bel[r]];i<=r;i++){
             ans=(a[i]+mark[bel[i]]+ans)%(c+1);
        } 
         
        for(int i=bel[l]+1;i<bel[r];i++){
             ans=(sum[i]+(ll)sz[i]*mark[i]%(c+1)+ans)%(c+1);
        }

    }
    return ans; 
	
}
int query1(int l,int r,int c){//区间查询,小于c的个数
    int ans=0;
    if(bel[l]==bel[r]){
        for(int i=l;i<=r;i++){
            if(a[i]+mark[bel[i]]<c*c) ans++;
        }
    }else{
        for(int i=l;i<=ed[bel[l]];i++){
            if(a[i]+mark[bel[l]]<c*c) ans++;
        } 
       
        for(int i=st[bel[r]];i<=r;i++){
            if(a[i]+mark[bel[r]]<c*c) ans++;
        } 
         
        for(int i=bel[l]+1;i<bel[r];i++){
            ans+=lower_bound(v[i].begin(), v[i].end(),c*c-mark[i])-v[i].begin();
        }

    }
    return ans; 
}
int query2(int l,int r,int c){//查询区间内比x小的最大元素 
    int ans=-1;
    if(bel[l]==bel[r]){
        for(int i=l;i<=r;i++){
            if(a[i]+mark[bel[i]]<c) ans=max(ans,a[i]+mark[bel[i]]); 
        }
    }else{
        for(int i=l;i<=ed[bel[l]];i++){
            if(a[i]+mark[bel[l]]<c) ans=max(ans,a[i]+mark[bel[l]]); 
        } 
       
        for(int i=st[bel[r]];i<=r;i++){
            if(a[i]+mark[bel[r]]<c) ans=max(ans,a[i]+mark[bel[r]]); 
        } 
         
        for(int i=bel[l]+1;i<bel[r];i++){
        	int t=lower_bound(v[i].begin(), v[i].end(),c-mark[i])-v[i].begin();
        	if(t){
        		ans=max(ans,v[i][t-1]+mark[i]);
			}
        }

    }
    return ans; 
}
int query3(int l,int r){//区间开方的求和 
	int ans=0;
    if(bel[l]==bel[r]){
        for(int i=l;i<=r;i++){
            ans+=a[i]+mark[bel[i]];
        }
    }else{
        for(int i=l;i<=ed[bel[l]];i++){
            ans+=a[i]+mark[bel[i]];
        } 
       
        for(int i=st[bel[r]];i<=r;i++){
             ans+=a[i]+mark[bel[i]];
        } 
         
        for(int i=bel[l]+1;i<bel[r];i++){
             ans+=sum[i];
        }

    }
    return ans; 
	
}

void solve_sqrt(int x){//对整块开放后的区间处理sum 
	if(flag[x]) return;//flag!=0即整块不用处理 
	flag[x]=1;
	sum[x]=0;
	for(int i=st[x];i<=ed[x];i++){
		a[i]=sqrt(a[i]);
		sum[x]+=a[i];
		if(a[i]>1) flag[x]=0;
	}
}
void changeSqrt(int l,int r){//区间开方 
	if (bel[l] == bel[r]) {
        for (int i = l; i <= r; i++) {
        	sum[bel[i]]-=a[i];
            a[i] =sqrt(a[i]);
            sum[bel[i]]+=a[i];
        }
      
       
    } else {
        for (int i = l; i <= ed[bel[l]]; i++){
        	sum[bel[i]]-=a[i];
            a[i] =sqrt(a[i]);
            sum[bel[i]]+=a[i];
		}
           
        for (int i = st[bel[r]]; i <= r; i++){
        	sum[bel[i]]-=a[i];
            a[i] =sqrt(a[i]);
            sum[bel[i]]+=a[i];
		}
      
        for (int i = bel[l] + 1; i < bel[r]; i++){
        	solve_sqrt(i);
		}
    }
} 

int main() {
    cin>>n;

    for (int i = 1; i <= n; i++)
        cin>>a[i];

    int l, r, op;
    ll c;
    sq=sqrt(n);

     init(n);
    int cnt=0;

    for (int i = 1; i <= n; i++) {
        cin>>op>>l>>r>>c;

        if (op == 0) {
            insert(l,r);cnt++;
        } else {
        	auto t=query4(r);
           cout<<v[t.first][t.second]<<endl;
        }
        if(cnt==sq){
        	rebuild();
        	cnt=0;
		}
    }
}

数列分块入门 7

1.题意：

区间乘法，区间加法，单点询问

2.题解：

本质上和区间加法差不多，更新零散块后再暴力，对整块做整块标记处理。

3.ac代码：
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
const int N = 1e6 + 10;
const int mod = 10007;
ll a[N];
int n, m;
int sq;
int st[N], ed[N], sz[N], sum[N], bel[N];
int flag[N];
ll multi[N], mark[N];
vector<int> v[N];
inline void init(int n) { //分块
    sq = sqrt(n);

    for (int i = 1; i <= sq; i++) {
        st[i] = sq * (i - 1) + 1;
        ed[i] = sq * i;
        sz[i] = ed[i] - st[i] + 1;

    }

    ed[sq] = n;
    sz[sq] = ed[sq] - st[sq] + 1;

    for (int i = 1; i <= sq; i++) {
        multi[i] = 1;

        for (int j = st[i]; j <= ed[i]; j++) {
            bel[j] = i;
            v[i].push_back(a[j]);
            sum[i] += a[j];
        }

        // sort(v[i].begin(),v[i].end());
    }

}
void reset(int i) { //排序v

    for (int j = 0; j <= sz[i]; j++) {
        v[i][j] = a[st[i] + j];
    }

    sort(v[i].begin(), v[i].end());
}
void rebuild() { //重新分块
    int k = 0;

    for (int i = 1; i <= sq; i++) {
        for (int j = 0; j < v[i].size(); j++) {
            a[++k] = v[i][j];
        }

        v[i].clear();
    }

    sq = sqrt(k);


    for (int i = 1; i <= k; i++) {

        v[(i - 1) / sq + 1].push_back(a[i]);
    }
}
inline void change(int l, int r, int d) { //区间修改,加上一个数

    if (bel[l] == bel[r]) {
        for (int i = l; i <= r; i++) {
            a[i] += d;
            sum[bel[i]] += d;
        }

        reset(bel[l]);

    } else {
        for (int i = l; i <= ed[bel[l]]; i++)
            a[i] += d, sum[bel[i]] += d;

        reset(bel[l]);

        for (int i = st[bel[r]]; i <= r; i++)
            a[i] += d, sum[bel[i]] += d;

        reset(bel[r]);

        for (int i = bel[l] + 1; i < bel[r]; i++)
            mark[i] += d;
    }
}
pair<int, int> query4(int x) {
    int i = 1;

    while (x > v[i].size()) {
        x -= v[i].size();
        i++;
    }

    return make_pair(i, x - 1);
}
//void insert(int l, int r) { //单点插入，在第l个数字前插入r
//    auto t = query4(l);
//    v[t.first].insert(v[t.first].begin() + t.second, r);
//
//}
int query(int l, int r, int c) { //区间和mod(c+1)
    int ans = 0;

    if (bel[l] == bel[r]) {
        for (int i = l; i <= r; i++) {
            ans = (a[i] + mark[bel[i]] + ans) % (c + 1);
        }
    } else {
        for (int i = l; i <= ed[bel[l]]; i++) {
            ans = (a[i] + mark[bel[i]] + ans) % (c + 1);
        }

        for (int i = st[bel[r]]; i <= r; i++) {
            ans = (a[i] + mark[bel[i]] + ans) % (c + 1);
        }

        for (int i = bel[l] + 1; i < bel[r]; i++) {
            ans = (sum[i] + (ll)sz[i] * mark[i] % (c + 1) + ans) % (c + 1);
        }

    }

    return ans;

}
int query1(int l, int r, int c) { //区间查询,小于c的个数
    int ans = 0;

    if (bel[l] == bel[r]) {
        for (int i = l; i <= r; i++) {
            if (a[i] + mark[bel[i]] < c * c)
                ans++;
        }
    } else {
        for (int i = l; i <= ed[bel[l]]; i++) {
            if (a[i] + mark[bel[l]] < c * c)
                ans++;
        }

        for (int i = st[bel[r]]; i <= r; i++) {
            if (a[i] + mark[bel[r]] < c * c)
                ans++;
        }

        for (int i = bel[l] + 1; i < bel[r]; i++) {
            ans += lower_bound(v[i].begin(), v[i].end(), c * c - mark[i]) - v[i].begin();
        }

    }

    return ans;
}

int query3(int l, int r) { //区间开方的求和
    int ans = 0;

    if (bel[l] == bel[r]) {
        for (int i = l; i <= r; i++) {
            ans += a[i] + mark[bel[i]];
        }
    } else {
        for (int i = l; i <= ed[bel[l]]; i++) {
            ans += a[i] + mark[bel[i]];
        }

        for (int i = st[bel[r]]; i <= r; i++) {
            ans += a[i] + mark[bel[i]];
        }

        for (int i = bel[l] + 1; i < bel[r]; i++) {
            ans += sum[i];
        }

    }

    return ans;

}

void solve_sqrt(int x) { //对整块开放后的区间处理sum
    if (flag[x])
        return;//flag!=0即整块不用处理

    flag[x] = 1;
    sum[x] = 0;

    for (int i = st[x]; i <= ed[x]; i++) {
        a[i] = sqrt(a[i]);
        sum[x] += a[i];

        if (a[i] > 1)
            flag[x] = 0;
    }
}
void changeSqrt(int l, int r) { //区间开方
    if (bel[l] == bel[r]) {
        for (int i = l; i <= r; i++) {
            sum[bel[i]] -= a[i];
            a[i] = sqrt(a[i]);
            sum[bel[i]] += a[i];
        }


    } else {
        for (int i = l; i <= ed[bel[l]]; i++) {
            sum[bel[i]] -= a[i];
            a[i] = sqrt(a[i]);
            sum[bel[i]] += a[i];
        }

        for (int i = st[bel[r]]; i <= r; i++) {
            sum[bel[i]] -= a[i];
            a[i] = sqrt(a[i]);
            sum[bel[i]] += a[i];
        }

        for (int i = bel[l] + 1; i < bel[r]; i++) {
            solve_sqrt(i);
        }
    }
}
void update(int l) {

    for (int i = st[l]; i <= ed[l]; i++) {
        a[i] = (multi[l] * a[i]%mod + mark[l]) % mod;
    }

    multi[l] = 1;
    mark[l] = 0;
}
void change(int op, int l, int r, int d) { //乘法，加法
    update(bel[l]);
    

    if (op == 0) {
        if (bel[l] == bel[r]) {
            for (int i = l; i <= r; i++) {
                a[i]=(a[i]+d)%mod;
            }
        } else {
        	update(bel[r]);
            for (int i = l; i <= ed[bel[l]]; i++)
               a[i]=(a[i]+d)%mod;

            for (int i = st[bel[r]]; i <= r; i++)
                a[i]=(a[i]+d)%mod;

            for (int i = bel[l] + 1; i < bel[r]; i++)
                mark[i]=(mark[i]+d)%mod;
        }

    } else {
        if (bel[l] == bel[r]) {
            for (int i = l; i <= r; i++) {
                a[i] = a[i] *d % mod;
            }
        } else {
        	update(bel[r]);
            for (int i = l; i <= ed[bel[l]]; i++)
                 a[i] = a[i] *d % mod;

            for (int i = st[bel[r]]; i <= r; i++)
                 a[i] = a[i] *d % mod;

            for (int i = bel[l] + 1; i < bel[r]; i++)
                multi[i]= d *multi[i] % mod,mark[i]=mark[i]*d%mod;//!!!切记乘法 对加法标记也要乘上去 
        }

    }
}
int main() {
    cin >> n;

    for (int i = 1; i <= n; i++)
        cin >> a[i];


    int l, r, op;
    ll c;
    sq = sqrt(n);

    init(n);

    for (int i = 1; i <= n; i++) {
        cin >> op >> l >> r >> c;

        if (op == 2) {
            cout << (multi[bel[r]]*a[r]%mod + mark[bel[r]]) % mod << endl;
        } else {
            change(op, l, r, c);
        }

    }
}

数列分块入门 8

1.题意：

操作涉及区间询问等于一个数 的元素，并将这个区间的所有元素改为 。

2.题解：

整块变化则将整块标记，跟前面的题类似
易错：1.传参传的是组号，不是区间短点，2.注意参数到底是谁

3.ac代码：
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
const int N = 2e5 + 10;

const int INF=0x3f3f3f3f;
ll a[N];
int n, m;
int sq;
int st[N], ed[N], sz[N], sum[N], bel[N];
int num[N];
ll multi[N], mark[N];
vector<int> v[N];
inline void init(int n) { //分块
    sq = sqrt(n);

    for (int i = 1; i <= sq; i++) {
        st[i] = sq * (i - 1) + 1;
        ed[i] = sq * i;
        sz[i] = ed[i] - st[i] + 1;

    }

    ed[sq] = n;
    sz[sq] = ed[sq] - st[sq] + 1;

    for (int i = 1; i <= sq; i++) {
        multi[i] = 1;

        for (int j = st[i]; j <= ed[i]; j++) {
            bel[j] = i;
            v[i].push_back(a[j]);
            sum[i] += a[j];
        }

        // sort(v[i].begin(),v[i].end());
    }
    

}







void update1(int x){
	if(num[x]==-1) return;
	for(int i=st[x];i<=ed[x];i++){
		a[i]=num[x];
	}
	num[x]=-1;
}


//void change(int op, int l, int r, int d) { //乘法，加法

int query4(int l,int r,int c){//查询区间中c的个数，并把区间所有数组改成c 
	int sum=0;
	update1(bel[l]);
	if(bel[l]==bel[r]){
		for(int i=l;i<=r;i++){
			if(a[i]==c) sum++;
			else a[i]=c;
		}
	}else{
		for(int i=l;i<=ed[bel[l]];i++){
			if(a[i]==c) sum++;
			else a[i]=c;
		}
		update1(bel[r]);
		for(int i=st[bel[r]];i<=r;i++){
			if(a[i]==c) sum++;
			else a[i]=c;
		}
		for(int i=bel[l]+1;i<bel[r];i++){
			if(num[i]==-1){
				for(int j=st[i];j<=ed[i];j++){
					if(a[j]==c) sum++;
					else a[j]=c;
				}
				num[i]=c;
			}else{
				if(num[i]==c) sum+=sz[i]; 
				num[i]=c;
			}
		}
		
	}
	return sum;
}
int main() {
    cin >> n;
    memset(num,-1,sizeof num);

    for (int i = 1; i <= n; i++){
    	cin >> a[i];
    	
	}
        


    int l, r, op;
    ll c;
    sq = sqrt(n);

    init(n);

    for (int i = 1; i <= n; i++) {
        cin  >> l >> r >> c;
        cout<<query4(l,r,c)<<endl;
        

    

    }
}

数列分块入门 9

1.题意：

离线的区间众数

2.题解：

!!!太好了啊啊啊啊啊啊啊啊啊啊啊啊，卡了我一下午，要不t要不wa要不re，终于终于！！
一开始错在，考虑了每个分块的众数，结果没有考虑几个块合成大块的众数
后来又是re，re，开始一直以为是数组越界，后来发现好像是数字太大了，不能z直接通过桶排计算，然后看别人代码学做了离散化
离散化后依旧re，然后把分块大小从√n变成了80
好了现在又是t了，不过好歹是80+，经过不断的改代码，我把map变成了普通的数组cnt，ookk终于过了！！，一个map让我超时了好久，我估计我用的pair也给我加了不少时，呜呜呜，我以后还老老实实用普通数组吧

总结下，这题基本思路：初始化求出不同块的众数+离散化+分块大小80+少用map等
历时几天的分块九题终于完了！！！撒花，感谢这位博主题解写的好！！

这题好像还能用莫队，回头试试

3.ac代码：
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
const int N = 1e6 + 10;
int f[5003][5003];
const int INF = 0x3f3f3f3f;
int a[N];
int n;
int sq;
int st[N], ed[N], sz[N], sum[N], bel[N];
int num[N];
ll multi[N], mark[N];
int cnt[N];
vector<int> v[N];
map<int, int> m;
int dis[N];
int count(int x, int l, int r) {
    return upper_bound(v[x].begin(), v[x].end(), r) - lower_bound(v[x].begin(), v[x].end(), l);
}

inline void init(int n) { //分块

    int val = 80;
    sq = (n - 1) / val + 1;


    for (int i = 1; i <= sq; i++) {
        st[i] = val * (i - 1) + 1;
        ed[i] = val * i;
        sz[i] = ed[i] - st[i] + 1;

    }

    ed[sq] = n;
    sz[sq] = ed[sq] - st[sq] + 1;

    for (int i = 1; i <= sq; i++) {
        for (int j = st[i]; j <= ed[i]; j++) {
            bel[j] = i;

        }
    }

    for (int i = 1; i <= sq; i++) {
        int maxx = INF, maxn = 0;
        memset(cnt, 0, sizeof cnt);

        for (int k = i; k <= sq; k++) {
            for (int j = st[k]; j <= ed[k]; j++) {

                cnt[a[j]]++;

                if (cnt[a[j]] > maxn) {
                    maxn = cnt[a[j]];
                    maxx = a[j];
                } else if (cnt[a[j]] == maxn) {
                    maxx = min(maxx, a[j]);
                }

            }

            f[i][k] = maxx;
        }


    }


}
pair<int, int> query5(int l, int r) {
    int ans = 0, ansx;
    pair<int, int> temp;
    temp = {INF, 0};

    if (bel[l] == bel[r]) {
        memset(cnt, 0, sizeof cnt);

        for (int i = l; i <= r; i++) {
            cnt[a[i]]++;

            if (cnt[a[i]] > temp.second) {
                temp = {a[i], cnt[a[i]]};
            } else if (cnt[a[i]] == temp.second) {
                temp.first = min(temp.first, a[i]);
            }
        }
    } else {

        int tot;

        for (int i = l; i <= ed[bel[l]]; i++) {
            tot = count(a[i], l, r);

            if (tot > temp.second) {
                temp = {a[i], tot};
            } else if (tot == temp.second) {
                temp.first = min(temp.first, a[i]);
            }
        }

        for (int i = st[bel[r]]; i <= r; i++) {
            tot = count(a[i], l, r);

            if (tot > temp.second) {
                temp = {a[i], tot};
            } else if (tot == temp.second) {
                temp.first = min(temp.first, a[i]);
            }
        }

        if (bel[l] + 1 < bel[r]) {
            int t = f[bel[l] + 1][bel[r] - 1];
            tot = count(t, l, r);

            if (tot > temp.second) {
                temp = {t, tot};
            } else if (tot == temp.second) {
                temp.first = min(temp.first, t);
            }
        }


    }

    return temp;
}
int main() {
    cin >> n;
    memset(num, -1, sizeof num);

    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        dis[++dis[0]] = a[i];
    }

    sort(dis + 1, dis + dis[0] + 1);

    for (int i = 1; i <= dis[0]; i++) {
        m[dis[i]] = i;
    }

    for (int i = 1; i <= n; i++) {
        a[i] = m[a[i]];
    }

    for (int i = 1; i <= n; i++) {
        v[a[i]].push_back(i);
    }



    int l, r, op;
    ll c;
    sq = sqrt(n);

    init(n);

    for (int i = 1; i <= n; i++) {
        cin  >> l >> r ;
        cout << dis[query5(l, r).first] << endl;




    }
}
平平无奇的问题制造小能手
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
1 数列分块入门_[知识点]数列分块入门1-9
weixin_39779004的博客
12-20 95
一、前言对线段树还挺熟悉的我之前却从没写过分块的题(？)。然后兴致一来就决定搜点练习，找到了来自hzwer的《数列分块入门1-9》，觉得挺不错的，于是决定做做。二、概念 / 作用概念：将数列等分为若干个不相交的区间，每一个区间称为一个块。作用：优化算法，降低复杂度。具体如何降低，在下面的题目中会逐步提及。题目呈难度递增趋势。三、题目 / 代码题面：给出一个长为 n 的数列，以及 n 个操作，操作涉...
数列分块入门1 – 9 by hzwer
剑锋OI SharpSwordOI
04-11 1017
数列分块入门1 – 9 by hzwer 本文非原创，原创地址http://hzwer.com/8053.html - 可能涉及的几个词语解释： 区间：数列中连续一段的元素 区间操作：将某个区间[a,b]的所有元素进行某种改动的操作 块：我们将数列划分成若干个不相交的区间，每个区间称为一个块 整块：在一个区间操作时，完整包含于区间的块 不完整的块：在一个区间操作时，只有部分包含于区间的块...
数列分块入门1-9 By hzwer
weixin_30632899的博客
08-13 166
声明 持续更新，因为博主也是正在学习分块的知识，我很菜的，菜的抠$jio$ 写在前面 分块是个很暴力的算法，但却比暴力优秀的多，分块算法的时间复杂度一般是根号的，他的主要思想是将一个长度是$n$的数列分为$m$个块,在每个块上维护一些东西，询问的时候才会用到这些维护的东西，就像线段树中的懒标记一样。 Loj #6297. 数列分块入门1 这道题目是分块最基础的题目，仅需要支...
数列分块入门1-9
qq_51281451的博客
08-15 664
这里写目录标题数列分块入门1数列分块入门2 数列分块入门1 Description 给出一个长为n 的数列，以及 n 个操作，操作涉及区间加法，单点查值。 Input 第一行输入一个数字n。 第二行输入n个数字，第i个数字为ai，以空格隔开。 接下来输入n行询问，每行输入四个数字opt,l,r,c，以空格隔开。 若opt=0，表示将位于[l,r]的之间的数字都加c。 若opt=1，表示询问ar 的值（l和c忽略） Output 对于每次询问，输出一行一个数字表示答案。 Samples Input 4 1
数列分块入门1-9 LibreOJ
weixin_30257433的博客
05-25 125
我也不知道为什么一个大二的ACM选手没学分块。 我怎么记得大一的时候，学长教给我的分块就只有 block 和 num 两个变量来着...好吧，应该是我没认真学。正好前两天朋友给学弟开课，乘机去蹭了一节课。然后...我还是不会哇，菜的一逼塌糊涂。 还是 卿学姐 好哇，多听几遍，睡得贼香。 分块原理 分块嘛，其实就是优雅的暴力，和莫队（不会）有点异曲同工的赶脚。通过将数组分成小块以降低复杂度。 通常情...
算法-数列分块入门 7（LibreOj-6283）.rar
09-16
《算法-数列分块入门 7（LibreOj-6283）》是针对计算机科学领域中的一种常用算法技巧——数列分块进行深入解析的教程。数列分块是一种优化线性结构查询的技术，常用于解决大规模数据处理问题，尤其是在动态维护和...
算法-数列分块入门 8（LibreOj-6284）.rar
09-16
《算法-数列分块入门 8（LibreOj-6284）》是针对编程算法学习者的一份重要资源，主要讲解了数列分块这一算法思想及其在解决实际问题中的应用。数列分块作为一种优化数据结构和算法效率的方法，在处理大规模数据时尤...
算法-数列分块入门 1（LibreOj-6277）.rar
09-16
这个压缩包文件“算法-数列分块入门 1（LibreOj-6277）.rar”包含了一份PDF文档，旨在引导初学者了解并掌握数列分块的基本概念和应用。 数列分块的核心思想是将一个大的、连续的数列分成若干个小的、连续的子序列...
算法-数列分块入门 9（LibreOj-6285）.rar
09-16
《算法-数列分块入门 9（LibreOj-6285）》是针对计算机科学领域中的一种常用优化技巧——数列分块技术的详细讲解。数列分块是解决大规模数据处理问题时的一种高效策略，尤其在算法竞赛如LibreOj等在线判题平台上，...
算法-数列分块入门 6（LibreOj-6282）.rar
09-16
《算法-数列分块入门 6（LibreOj-6282）》是针对计算机算法领域中一种常用的技术——数列分块技术进行详细介绍的资源。数列分块是解决大规模数据处理和在线算法问题时的一种有效策略，尤其在面对动态查询和更新的...
数列分块入门1-9（未完）
坚持迟早会有收获的！！！
05-12 350
链接：数列分块入门数列分块入门1：题意：区间更新，单点查询代码：#include&lt;bits/stdc++.h&gt; using namespace std; typedef long long ll; const int mx = 50010; int num, block; int l[mx], r[mx]; int belong[mx]; int a[mx]; int add[mx]...
CF1400E. Clear the Multiset（分治，递归）
m0_51055929的博客
10-04 174
题目链接：https://codeforces.ml/contest/1400/problem/E 描述： 给出序列a,有两种操作： 1.将区间[l,r]的数减一。 2.将a[x]变为0. 求将a全变为0最少的操作步数。n<=5000,0<=a[i]<=1e9; 分析： 区间由0被分为若干个小区间，每个区间若经过x次操作一后，无法消去>=x个数，则说明操作二更优。所以可以分治，对一个区间，找出最小值min，然后进行min次操作一，将区间分文若干小区间，然后在解决小区间。
【分块入门】LOJ 数列分块入门 1 - 9 (学习更新……)
L_X_
01-16 2047
dl题解_「分块」数列分块入门1 – 9 by hzwer LOJ #6277. 数列分块入门 1 题意：给出一个长为n的数列，以及n个操作，操作涉及区间加法，单点查值。 时间限制：100ms 分块 我们将整个数列划分为很多块，暂且分为n / m块，用block[ i ]记录第 i 个数据arr[ i ]对应的块的个数。O(n)【数据读入时就可以操作完成，block[ i ] = (i ...
分块大法好：数列分块入门1~9
kkkGIGi_qtt
03-28 4271
艰苦地刷了4天半的分块 深感分块是一个非常巧（暴）妙（力） 的算法 如果有觉得hzwer的代码太奇妙（看不懂）的推荐一下机房大佬的通俗易懂的代码： http://www.cnblogs.com/CHerish_OI/category/1176577.html（此处手动艾特cherish_oi同学） http://hzwer.com/8053.html loj#6277. 数列分块入门...
【数列分块入门】1~9全题解
小明的博客
05-31 1373
欢迎光临小店问题 A: 数列分块入门1问题 B: 数列分块入门 2问题 C: 数列分块入门 3（待补）问题 D: 数列分块入门 4（树状数组的操作）问题 E: 数列分块入门 5问题 F: 数列分块入门 6 店面不大，请多包涵，哈哈哈哈哈 问题 A: 数列分块入门1 时间限制: 1Sec1 Sec1Sec 内存限制: 256MB256 MB256MB 题目描述 给出一个长为nnn的数列，以及 nnn 个操作，操作涉及区间加法，单点查值 输入 第一行输入一个数字nnn。 第二行输入nnn个数字，第i个数字为a
分块入门1~9 （完结撒花）
包子不卖包子
08-23 448
LOJ 终于肝完了分块的九种基础类型，调bug调得是真（超）是（级）开（恶）心。 有脑残的时候，把块的编号当成元素的下表。数组开太小会莫名超时。 建议读者刷LOJ上的分块入门1~9 loj#6277. 数列分块入门 1 区间加法，单点查询 基础的东西 数学老师曰：基本知识不熟悉，难题不会做！ 分块 每个块的大小都是sqrt（n） n=12 N=sqrt（12） 向下取整 3 第一块：1...
2021 ICPC Asia EC网络预选赛I、II
weixin_46064382的博客
10-06 468
1.题意： 2.题解： 3.ac代码： 在这里插入代码片 1.题意： 2.题解： 3.ac代码： 在这里插入代码片 1.题意： 2.题解： 3.ac代码： 在这里插入代码片 1.题意： 2.题解： 3.ac代码： 在这里插入代码片 1.题意： 2.题解： 3.ac代码： 在这里插入代码片 1.题意： 2.题解： 3.ac代码： 在这里插入代码片 1.题意： 2.题解： 3.ac代码： 在这里插入代码片 1.题意： 2.题解： 3.ac代码： 在这里插入代码片 1.题意： 2.
2021-01-13Winter Camp 2021 Training 3训练题解
weixin_46064382的博客
01-16 255
contest 一.A. Phoenix and Balance 1.大意： 有n个数，分别是从2到2^n，将他们随机分成2堆（每堆都是n/2个），保证n是偶数，让两堆n/2个数的和的差最小 2.题解： 找规律，发现分成一堆为：2n/2,2n/2+1,…,2n-1,(共n/2个数）， 另一堆为·：21,22,…2n/2-1,2n, 这种情况两边和相差最小 推公式得：2n/2+1-2 用pow会T，用了快速幂 看了别人的方法，发现也可以是前一个数*2+2，实质差不多 3.ac代码： #include
2021-05-24异或线段树题1
weixin_46064382的博客
05-28 235
在 [first, last) 区域内查找 lower_bound(,x) 第一个>=x int a[5] = { 1,2,3,4,5 }; //从 a 数组中找到第一个不小于 3 的元素 int *p = lower_bound(a, a + 5, 3); *p=3 upper bound(,x) 第一个>x int a[5] = { 1,2,3,4,5 }; //从 a 数组中找到第一个大于 3 的元素 int *p = uppe
LOJ-6279-数列分块入门3(分块, 二分)
最新发布
05-24
题目描述 给定一个长度为n的序列a，有m次询问。每次询问给定l, r, k，要求区间[l, r]中第k小的数。 输入格式 第一行两个整数n,m。 接下来一行n个整数，表示序列a。 接下来m行，每行三个整数l,r,k。 输出格式 对于每个询问，输出一行一个数，表示区间[l, r]中第k小的数。 输入样例 5 3 1 3 2 4 5 1 5 2 2 4 1 3 5 3 输出样例 2 3 5 算法1 (分块) $O(n\sqrt n)$ 我们可以预处理出每一个块的信息，每个块又分为若干小块，每个小块中的数都小于等于块中的最大值，可以用二分查找确定小块中满足条件的数的个数，然后用根号分治处理。 时间复杂度 每次查询的时间复杂度是 $O(\sqrt n\log n)$ 的，总时间复杂度是 $O(n\sqrt n\log n)$ 的。 参考文献 算法竞赛进阶指南 C++ 代码 算法2 (二分答案) $O(n\log^2n)$ 我们二分答案，然后统计序列中小于等于这个答案的数的个数，统计方法可以用归并排序，在时间复杂度 $O(n\log n)$ 的时间内完成。 时间复杂度 每次查询的时间复杂度是 $O(n\log^2n)$ 的，总时间复杂度是 $O(mn\log^2n)$ 的。 参考文献 算法竞赛进阶指南 C++ 代码

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值