分块9题【参考hzw】

最新推荐文章于 2020-09-17 22:04:07 发布
最新推荐文章于 2020-09-17 22:04:07 发布
阅读量432 收藏 2
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CH_Vaniteux/article/details/86735493
版权

参考hzw大佬的blog

1

给出一个长为n的数列，以及n个操作，操作涉及区间加法，单点查值。

嗯 分块板子啦
贴下主要部分的代码

struct Block{
	int size, cnt, pos[N];
	int atag[N];
	inline int query(int x){
		return a[x] + atag[pos[x]];
	}
	inline void add(int x, int y, int d){
		for(int i = x; i <= min(pos[x] * size, y); ++i)
		    a[i] += d;
		if(pos[x] != pos[y])
		    for(int i = (pos[y] - 1) * size + 1; i <= y; ++i)
		        a[i] += d;
		for(int i = pos[x] + 1; i <= pos[y] - 1; ++i)
		    atag[i] += d;
	}
}bl;

2

给出一个长为n的数列，以及n个操作，操作涉及区间加法，询问区间内小于某个值x的元素个数

考察块内排序的维护

struct Block{
 int size, cnt, pos[N];
 int atag[sqN];
 vector<int> ve[sqN];
 void reset(int x){
  ve[x].clear();
  for(int i = (x - 1) * size + 1; i <= min(x * size, n); ++i){//min(, n)!!!
   ve[x].push_back(a[i]);
  }
  sort(ve[x].begin(), ve[x].end());
 }
 inline int query(int x, int y, int d){
  int res = 0;
  for(int i = x; i <= min(pos[x] * size, y); ++i){
   if(a[i] < d - atag[pos[x]]) ++res;
  }
  if(pos[x] != pos[y])
      for(int i = (pos[y] - 1) * size + 1; i <= y; ++i)
          if(a[i] < d - atag[pos[y]]) ++res;
  for(int i = pos[x] + 1; i <= pos[y] - 1; ++i){
   res += lower_bound(ve[i].begin(), ve[i].end(), d - atag[i]) - ve[i].begin();
  }
  return res;
 }
 inline void add(int x, int y, int d){
  for(int i = x; i <= min(pos[x] * size, y); ++i)
      a[i] += d;
  reset(pos[x]);
  if(pos[x] != pos[y]){
      for(int i = (pos[y] - 1) * size + 1; i <= y; ++i)
          a[i] += d;
      reset(pos[y]); 
  }
  for(int i = pos[x] + 1; i <= pos[y] - 1; ++i)
      atag[i] += d;
 }
}bl;

3

给出一个长为n的数列，以及n个操作，操作涉及区间加法，询问区间内小于某个值x的前驱（比其小的最大元素）。

考察维护块内前驱（当然后继同理

struct Block{
 int size, cnt, pos[N];
 int atag[sqN];
 set<int> st[sqN];
 inline int pre(int x, int y, int d){
  int res = -inf;
  set<int> :: iterator it;
  for(int i = x; i <= min(pos[x] * size, y); ++i){
   if(a[i] + atag[pos[x]] < d) res = max(res, a[i] + atag[pos[x]]);
  }
  if(pos[x] != pos[y])
      for(int i = (pos[y] - 1) * size + 1; i <= y; ++i)
          if(a[i] + atag[pos[y]] < d) res = max(res, a[i] + atag[pos[y]]);
  for(int i = pos[x] + 1; i <= pos[y] - 1; ++i){
      it = st[i].lower_bound(d - atag[i]);
      if(it == st[i].begin()) continue;
      --it;
      res = max(*it + atag[i], res);
  }
  return res == -inf ? -1 : res;
 }
 inline void add(int x, int y, int d){
  for(int i = x; i <= min(pos[x] * size, y); ++i){
   st[pos[x]].erase(a[i]);
      a[i] += d;
   st[pos[x]].insert(a[i]);
  }
  if(pos[x] != pos[y]){
      for(int i = (pos[y] - 1) * size + 1; i <= y; ++i){
       st[pos[y]].erase(a[i]);
          a[i] += d;
          st[pos[y]].insert(a[i]);
      }
  }
  for(int i = pos[x] + 1; i <= pos[y] - 1; ++i)
      atag[i] += d;
 }
}bl;

4

给出一个长为n的数列，以及n个操作，操作涉及区间加法，区间求和。

记得开longlong哦

struct Block{
	int size, cnt, pos[N];
    long long atag[sqN], sum[sqN];
	inline long long query(int x, int y, long long d){
		long long res = 0;
		for(int i = x; i <= min(pos[x] * size, y); ++i)
			res += a[i] + atag[pos[x]];
		if(pos[x] != pos[y])
		    for(int i = (pos[y] - 1) * size + 1; i <= y; ++i)
		        res += a[i] + atag[pos[y]];
		res %= d; 
		for(int i = pos[x] + 1; i <= pos[y] - 1; ++i){
		    res += sum[i] + atag[i] * size;
		    res %= d;
		}
		return res % d;
	}
	inline void add(int x, int y, long long d){
		for(int i = x; i <= min(pos[x] * size, y); ++i){
			sum[pos[x]] += d;
		    a[i] += d;
		}
		if(pos[x] != pos[y]){
		    for(int i = (pos[y] - 1) * size + 1; i <= y; ++i){
		    	sum[pos[y]] += d;
		        a[i] += d;
		    }
		}
		for(int i = pos[x] + 1; i <= pos[y] - 1; ++i)
		    atag[i] += d;
	}
}bl;

5

给出一个长为n的数列，以及n个操作，操作涉及区间开方，区间求和。

一个数经过几次开方就会变成0或1
所以维护一下这个块有没有全变成0或1就好啦

struct Block{
	int size, cnt, pos[N];
    long long sum[sqN];
	bool flag[sqN];
	inline long long query(int x, int y){
		long long res = 0;
		for(int i = x; i <= min(pos[x] * size, y); ++i)
			res += a[i];
		if(pos[x] != pos[y])
		    for(int i = (pos[y] - 1) * size + 1; i <= y; ++i)
		        res += a[i];
		for(int i = pos[x] + 1; i <= pos[y] - 1; ++i){
		    res += sum[i];
		}
		return res;
	}
	inline bool sq(int x){
		bool ret = 1;
		for(int i = (x - 1) * size + 1; i <= min(n, x * size); ++i){
			a[i] = sqrt(a[i]);
			if(ret && a[i] != 0 && a[i] != 1) ret = 0; 
		}
		sum[x] = 0;
		for(int i = (x - 1) * size + 1; i <= min(n, x * size); ++i){
			sum[x] += a[i];
		}
		return ret;
	}
	inline void modify(int x, int y){
		for(int i = x; i <= min(pos[x] * size, y); ++i){
			sum[pos[x]] -= a[i];
		    a[i] = sqrt(a[i]);
		    sum[pos[x]] += a[i];
		}
		if(pos[x] != pos[y]){
		    for(int i = (pos[y] - 1) * size + 1; i <= y; ++i){
				sum[pos[y]] -= a[i];
			    a[i] = sqrt(a[i]);
			    sum[pos[y]] += a[i];
		    }
		}
		for(int i = pos[x] + 1; i <= pos[y] - 1; ++i)
		    if(!flag[i]) flag[i] = sq(i);
	}
}bl;

6

给出一个长为n的数列，以及n个操作，操作涉及单点插入，单点询问，数据随机生成。

本题随机生成数据 用链表什么的直接插就行
不随机就要重构 有三种做法
1.每根号n次插入后，重新把数列平均分一下块
2.当某个块过大时重构
3.把特别大的块分成两半

struct Block{
	int size, cnt, pos[N];
	int stk[N], top;
	vector<int> ve[sqN];
	pair<int, int> query(int x){
		int i;
		for(i = 1; x > ve[i].size(); ++i)
		    x -= ve[i].size();
		return make_pair(i, x - 1);
	}
	void rebuild(){
		top = 0;
		for(int i = 1; i <= cnt; ++i){
			for(vector<int> :: iterator j = ve[i].begin(); j != ve[i].end(); ++j){
				stk[++top] = *j;
			}
			ve[i].clear();
		}
		size = sqrt(top);
		for(int i = 1; i <= top; ++i){
			pos[i] = (i - 1) / size + 1;//是/不是%！！！！！ 
			ve[pos[i]].push_back(stk[i]);
		}
		cnt = pos[top];
	}
	void ins(int x, int y){
		pair<int, int> t = query(x);
		ve[t.first].insert(ve[t.first].begin() + t.second, y);
	}
}bl;

7

给出一个长为 n 的数列，以及 n 个操作，操作涉及区间乘法，区间加法，单点询问。

这道题就是取一个优先级
和洛谷线段树2差不多
longlong竟然比int慢这么多【雾

struct Block{
	int size, cnt, pos[N];
	int atag[N], mtag[N];
	int query(int x){
	    return (a[x] * mtag[pos[x]] + atag[pos[x]]) % P;
	}
	inline void init(){
		for(int i = 1; i <= cnt; ++i){
			mtag[i] = 1;
		}
	}
	inline void reset(int x){
		for(int i = (x - 1) * size + 1; i <= min(x * size, n); ++i){
			a[i] = (a[i] * mtag[x] + atag[x]) % P;
		}
		mtag[x] = 1, atag[x] = 0;
	}
	void add(int x, int y, int d){
		reset(pos[x]);
	    for(int i = x; i <= min(y, pos[x] * size); ++i){
	    	a[i] = (a[i] + d) % P;
	    }
	    if(pos[x] != pos[y]){
	    	reset(pos[y]);
	    	for(int i = (pos[y] - 1) * size + 1; i <= y; ++i){
	    		a[i] = (a[i] + d) % P;
	    	}
	    }
	    for(int i = pos[x] + 1; i <= pos[y] - 1; ++i){
	    	atag[i] = (atag[i] + d) % P;
	    }
	}
	void mul(int x, int y, int d){
	    reset(pos[x]);
	    for(int i = x; i <= min(y, pos[x] * size); ++i){
	    	a[i] = (a[i] * d) % P;
	    }
	    if(pos[x] != pos[y]){
	    	reset(pos[y]);
	    	for(int i = (pos[y] - 1) * size + 1; i <= y; ++i){
	    		a[i] = (a[i] * d) % P;
	    	}
	    }
	    for(int i = pos[x] + 1; i <= pos[y] - 1; ++i){
	    	atag[i] = (atag[i] * d) % P;
	    	mtag[i] = (mtag[i] * d) % P;
	    }//注意这里的处理哦 
	}
}bl;

8

给出一个长为 n 的数列，以及 n 个操作，操作涉及区间询问等于一个数 c 的元素，并将这个区间的所有元素改为 c。

哇这一波复杂度证明真心阔以
今天才理解lxl那节课上讲的染色qvq
和开方那道题有一点类似
都是只能一个一个修改的东西
中间的值一样了就标记一下
这样虽然看起来不太可行
但实际上你修改两个端点 最多只能拆两个同色的块
要修改上 √n 个才能把复杂度拉到 O ( n ) O(n) O(n)
（有√n个不同色的块 每个需要√n复杂度维护）
那这么一平摊 又 O ( n √ n ) O(n √n) O(n√n)了。。。
懒得打根号

struct Block{
	int size, cnt, pos[N];
	int col[sqN];
	void init(){
		memset(col, -1, sizeof(col));
	}
	void reset(int x){
		if(col[x] == -1) return ;
		for(int i = (x - 1) * size + 1; i <= min(size * x, n); ++i)
		    a[i] = col[x];
		col[x] = -1; 
	}
	int modify(int x, int y, int d){
		int res = 0;
		reset(pos[x]);
	    for(int i = x; i <= min(y, pos[x] * size); ++i){
	    	if(a[i] == d) ++res;
	    	else a[i] = d;
	    }
	    if(pos[x] != pos[y]){
	    	reset(pos[y]);
	    	for(int i = (pos[y] - 1) * size + 1; i <= y; ++i){
	    	    if(a[i] == d) ++res;
	    	    else a[i] = d;
	        }
	    }
	    for(int i = pos[x] + 1; i <= pos[y] - 1; ++i){
	    	if(~col[i]){
	    		if(col[i] != d) col[i] = d;
	    		else res += size;
	    	}
	    	else {
	    		for(int j = (i - 1) * size + 1; j <= i * size; ++j){
	    			if(a[j] == d) ++res;
	    			else a[j] = d;
	    		}
	    		col[i] = d;
	    	}
	    }
	    return res;
	}
}bl;

9

给出一个长为n的数列，以及n个操作，操作涉及询问区间的最小众数。

忍住没有用莫队写
这是利用了本质的√n大法吧。。。

struct Block{
	int size, cnt, pos[N];
	int colcnt[N];
	void init(int x){
		int mx = 0, res;
		memset(colcnt, 0, sizeof(colcnt));
		for(int i = (x - 1) * size + 1, y; i <= n; ++i){
			y = ls[a[i]]; ++colcnt[y];
 			if(mx < colcnt[y] || (mx == colcnt[y] && val[res] > val[y])){
 				mx = colcnt[y]; res = y;
 			}
 			g[x][pos[i]] = mx;
 			f[x][pos[i]] = res;
		}
	}
	int ve_q(int x, int y, int c){
		return upper_bound(ve[c].begin(), ve[c].end(), y) - lower_bound(ve[c].begin(), ve[c].end(), x);
	}
	int query(int x, int y){
		int res = 0, mx = 0;
		if(pos[x] < pos[y] - 1){
			res = f[pos[x] + 1][pos[y] - 1]; mx = g[pos[x] + 1][pos[y] - 1];
		}
		for(int i = x, t, col; i <= min(y, pos[x] * size); ++i){
			col = ls[a[i]];
			t = ve_q(x, y, col);
			if(t > mx || (t == mx && val[col] < val[res])){
				mx = t, res = col;
			}
		}
		if(pos[y] != pos[x])
		for(int i = (pos[y] - 1) * size + 1, t, col; i <= y; ++i){
			col = ls[a[i]];
			t = ve_q(x, y, col);
			if(t > mx || (t == mx && val[col] < val[res])){
				mx = t, res = col;
			}
		}
	    return res;
	}
}bl;
CH_Vaniteux
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
分块入门 9题
J_lxj 的博客
02-25 567
分块的9题是跟着黄学长的博客写的，算是真正的入门了吧。 例题1：给出一个长为n的数列，以及n个操作，操作涉及区间加法，单点查值。 题解By hzwer: 这是一道能用许多数据结构优化的经典题，可以用于不同数据结构训练。数列分块就是把数列中每m个元素打包起来，达到优化算法的目的。以此题为例，如果我们把每m个元素分为一块，共有n/m块，每次区间加的操作会涉及O(n/m)个整块，以及区间两侧两个不完整的...
分块入门 LibreOJ分块九题
aoy29758的博客
07-23 318
推荐hzwer大佬的博客：http://hzwer.com/8053.html 初步学习体验就是，分块作为一种复杂度看上去并不优秀实际效率却很优秀的数据结构，在解决某些用其他如线段树等log数据结构非常麻烦的问题时非常好写好用，以后搭配莫队简直是解决大部分区间问题的强力算法 分块本身其实还是挺简单的，这套题总结了一些分块/数据结构的经典问题，很全面，能由浅入深地学习分块的基本使用，分...
分块九题
Mongo_w的博客
09-17 202
爆肝一天，终于写完了 分块入门 由于后半部分参考了dalao的博客，于是码风较前边有点区别 第一题 区间修改单点查询 讲真这题可以用CDQ分治写，而且通俗易懂，但这篇讲的是分块，所以我们只是贴一下代码： CDQ分治版： #include<iostream> #include<cstdio> using namespace std; typedef long long ll; const int N = 1000010; struct nod { ll x , y; i
分块九讲
weixin_30614109的博客
08-08 197
分块九讲 原作者：Hzwer 一 二 三 四 五 六 转载于:https://www.cnblogs.com/BigYellowDog/p/11323536.html
[LOJ] 分块九题 9
Memories Do Not Open
04-16 288
区间众数。占坑。
hzw-photos.rar
11-21
而本次我们要讨论的是一个特别的数据集——"hzw-photos.rar"，它为学习和研究提供了丰富的素材，特别是对于那些致力于图像分类和深度学习的学者和开发者来说，这是一个非常宝贵的资源。 这个压缩包文件名为"hzw-...
C# 2005 .NET微软认证题库
02-19
9. **ADO.NET**：连接和操作数据库，如SQL Server，使用Connection、Command、DataAdapter和DataSet等对象。 10. **.NET框架组件**：了解System命名空间下的各种类和库，如Collections、IO、Threading等，以及如何...
spring-boot-parent-hzw：弹簧引导构建学习
02-26
spring-boot-parent-hzw：弹簧引导构建学习
14 TeV LHC的HZW±产量的近乎领先的QCD校正
04-04
由于希格斯量规接头的精确研究对于测试标准模型（SM）非常重要，因此我们计算出在14 TeV LHC下SM中ppâHZW±产量的完全次于领先的QCD（NLO QCD）校正 。 我们的结果表明，当mH = 125.3 GeV时，NLO QCD校正可以将ppâ...
70-528 中文（Web应用开发-ASP.NET2.0）微软认证题库
11-01
9. **Web服务与AJAX** - **Web服务（ASMX）**: 创建和调用SOAP协议的Web服务。 - **AJAX技术**: 使用UpdatePanel、ScriptManager等控件实现页面局部刷新，提升用户体验。 通过70-528 中文（Web应用开发-ASP.NET...
[分块]入门题目
weixin_30394633的博客
05-09 123
https://loj.ac/problems/search?keyword=%E5%88%86%E5%9D%97 https://blog.csdn.net/keepcoral/article/details/80743559 数列分块入门 1 正确解法： 简单分块，然后区间之外的暴力，区间之内的 lazy 数组标记。 1 #include <iostr...
分块题集
weixin_33701617的博客
08-16 226
记得分块还是大一时学的，后来就没怎么写过，趁此时机，再重新巩固一下此专题。 1.普通分块题目 POJ 3468 后悔没有学习这么优秀的代码，自己当年写的就是一坨屎。 #include <cstdio> #include <algorithm> #include <cmath> using namespace std; typedef lo...
分块练习题
anp53732的博客
07-20 316
3809: Gty的二逼妹子序列 CDOJ 1157 数列(seq) 分块+线段树 2015北京网络赛 J Clarke and puzzle 求五维偏序 分块+bitset Codeforces Round #319 (Div. 1) C. Points on Plane 分块 2002: [Hnoi2010]Bounce 弹飞绵羊 LCT Codeforces Roun...
[LOJ] 分块九题 5
weixin_33858485的博客
04-12 116
区间开平方，区间查询。 lazy标记改为区间是否全是1或者0，这样的区间是没有更新价值的。 //Stay foolish,stay hungry,stay young,stay simple #include<iostream> #include<cmath> #include<cstdio> #include<cct...
LOJ分块9题
qq_45342177的博客
10-10 279
众所周知分块是一种非常优秀的暴力算法 T1 把我吊打（我生气了所以不想写这道题的题解） #include <cstdio> #include <iostream> #include <algorithm> #include <cmath> #include <cstring> #define ll long long using nam...
分块入门题
yeleng的博客
10-18 391
分块入门题5： 给[L,R]取开方，一个数字最多被取开方6次，那么一个块内有需要开方的时候才对这个块取开方，那么最多6*n*sqrt(n)次，分块直接写 #include&lt;bits/stdc++.h&gt; using namespace std; typedef long long ll; const int maxn=1e5+7; int l[5500],r[5500],belon...
跟着hzw学习数列分块
wjmwsgj的博客
07-23 340
前言 早就看过黄学长这篇博客一直没有学习过，写牛客的第一场多校的时候有一道莫队的题，之后突然想起来这篇，所以学习了一下，不得不说这种分块儿思想，真是优美的暴力啊~下面我会上9道题(其实就是黄学长博客上面的题)来简述一下分块这种思想 。 一 给出一个长为 nn{n} 的数列，以及 nn{n} 个操作，操作涉及区间加法，单点查值。 思路：这道题可以用很多数据结构写，我们这里引入分块...
分块练习
slongle的专栏
04-02 723
[CodeVS1080]题目大意支持1.单点修改2.区间和查询题解分块维护区间和 CODE[BZOJ1901] Zju2112 Dynamic Rankings题目大意支持1.单点修改2.区间第k大查询题解分块,块内维护递增序列 修改时,二分找到要修改的在块内的位置,再对块重建快排,O(Mn−−√logn−−√)O(M\sqrt{n}log\sqrt{n}) 查询时,二分答案,查询区间内<=a
oracledba面试题
最新发布
12-27
以下是关于Oracle DBA面试题的回答： 1. 如何杀死一个会话？ ```sql alter system kill session 'sid,serial#'; ``` 2. DML、DDL和DCL在Oracle中的使用简述： - DML（Data Manipulation Language）用于对数据库中的数据进行操作，包括插入、更新、删除等操作。常见的DML语句有INSERT、UPDATE和DELETE。 - DDL（Data Definition Language）用于定义数据库对象，包括表、视图、索引等。常见的DDL语句有CREATE、ALTER和DROP。 - DCL（Data Control Language）用于控制数据库用户的访问权限，包括授权和回收权限。常见的DCL语句有GRANT和REVOKE。 3. 如何在会话中启用SQL跟踪？ ```sql exec dbms_system.set_sql_trace_in_session(sid,serial#,&sql_trace); ``` 4. 如何查询当前会话的SID和SERIAL#？ ```sql select sid,serial# from v$session where sid = (select sid from v$mystat where rownum = 1); ``` 5. 如何在会话中设置事件级别？ ```sql exec dbms_system.set_ev(&sid,&serial#,&event_10046,&level_12,''); ``` 6. SQL调整最关注的是什么？ SQL调整最关注的是优化查询性能，包括减少查询时间、降低资源消耗和提高系统响应速度等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值