根号科技概览Chapter1 -- 前言与小技巧(alpha版)
参考资料
《根号算法--不只是分块》 王悦同 ———— 2014集训队论文
《lxl的大分块》———— nzhtl1477
《根号算法》 ———— ckw
前言
近一年 lxl 题开始更频繁地进入大众视野了orz。
然后我就想学啦。
不想定目标, 最后发出来的是 Chapter几 就算 Chapter几 吧。
自然整除分块
其实就是一个结论, 对于整数 \(n,k\), 整除运算 \(\lfloor \frac{n}{k} \rfloor\) 的不同的值的个数是 \(O(\sqrt n)\) 的。
证明很简单, 先不考虑整除等于 0 的情况, 对于 \(k\) 落在 \([1,n]\) 的情况, 分 \(k \in [1, \sqrt n]\) 和 \(k \in (\sqrt n, n]\) 两种即可。
具体应用上主要是用于求和, 求这样一类式子:
其中, \(\sum_{i=l}^r f(i)\) 可以快速求。
这种问题用的是这样一个相关结论:最大的使得 \(\lfloor \frac{n}{s} \rfloor = q\) 的 \(s\) 是 \(\lfloor \frac{n}{q} \rfloor\)。
这样就可以把像 \(\lfloor \frac{n_k}{i} \rfloor\) 的形式分别划分成 \(O(\sqrt n_k)\) 段, 然后将这些段 “并起来”, 这样对于每段里的每个 \(i\) 来说, \(\lfloor \frac{n_1}{i} \rfloor \lfloor \frac{n_2}{i} \rfloor \cdots \lfloor \frac{n_k}{i} \rfloor\) 都是相同的, 就可以这样计算这一段的和:
这样计算的复杂度是 \(O(\sum_k \sqrt n_k)\)(段并起来的段数上界, 实际上还要乘上计算每一段的复杂度, 但是被我当成常数了), 在 \(k\) 较小的时候比较快, 比如这个例题, \(k=1\):[清华集训2012]模积和, 我的远古题解。
再比如这个例题, \(k=2\) : YY的GCD, 我的题解。
数据分治与根号平衡
大数阶乘取模
打一个表, 相邻两个数间隔一个固定的长度 \(T\), 可以以表中的一个数为起点, 空间复杂度低, 时间复杂度就降到 \(O(T)\) 了。(大概)
另一道例题
每次操作要把 \(q = O(\lceil \frac{n}{p} \rceil)\) 个数加起来, 这 \(q\) 个数是可以用 \(O(q)\) 的时间找到并加起来的, 暴力的总复杂度就是 \(O(\sum_{i=1}^m q_i)\), 要是 \(q_i\) 都很小该多好啊orz。
最终的算法就是:设定一个阈值 \(T\), 对于 \(q \le T\) 的询问暴力做, 对于 \(q \in (T,n]\) 的询问, 记录答案; 每个修改都暴力修改就行。
思考 \(q\) 很神必, 改为思考 \(p\) : 设立一个阈值 \(T\), 对于 \(p \in [1,T]\), 开一个数组 \(f[1 \le i \le T][0 \le j < T]\) 表示 膜 \(i\) 为 \(j\) 的答案, 剩下的情况暴力算; 修改的时候在这个数组中枚举 \(i\), 维护数组。
时间复杂度如此:
询问: \(p \in [1,T], \; O(1)\), \(else, \; O(\lfloor \frac{n}{T} \rfloor)\)
修改: \(O(T)\)
这是一个可以自行平衡 查-改 复杂度的关系, 题目并没有对于 查-改 数量差的偏好, 所以规定 \(O(T) = O(\lfloor \frac{n}{T} \rfloor)\), 解得 \(T = O(\sqrt n)\)。
(下一道例题会更详细地讲这类复杂度平衡的方法, 虽然只是详细了一点点, 不过更有逻辑性)
代码就可以写出来了。
using namespace std;
const int N = 150003;
const int B = 391;
int n,m,a[N];
int T, f[B][B];
int calc(int x,int y) {
int res = 0;
while(y <= n) {
res += a[y];
y += x;
}
return res;
}
int main() {
scanf("%d%d", &n,&m);
for(int i=1;i<=n;++i) scanf("%d", &a[i]);
T = sqrt(n*1.0);
for(int i=1;i<=T;++i)
for(int j=1;j<=n;++j)
f[i][j%i] += a[j];
while(m--) {
char cmd[3];
int x,y;
scanf("%s%d%d", cmd, &x, &y);
if(cmd[0] == 'A') {
if(x <= T) cout << f[x][y] << '\n';
else cout << calc(x,y) << '\n';
} else {
for(int i=1;i<=T;++i)
f[i][x%i] -= a[x], f[i][x%i] += y;
a[x] = y;
}
}
return 0;
}
题意简述:
给定节点数为 \(N \in [1,2e5]\) 的有根树, 节点有颜色 \(\in [1,R]\) , \(R\) 给定; 有 \(Q \in [1,2e5]\) 次询问, 每次询问形如 \(r_1,r_2 \in [1,R]\), 要求输出满足 \(e_1\) 颜色为 \(r_1\) 且 \(e_2\) 颜色为 \(r_2\) 且 \(e_1\) 为 \(e_2\) 祖先的二元组 \((e_1,e_2)\) 的个数。
设 \(col[x]\) 表示节点 \(x\) 的颜色
设 \(num[r]\) 表示颜色为 \(r\) 的节点数。
对于一个询问 \((r_1,r_2)\), 有两种计算方式:
- 枚举 \(e_1\) 满足 \(col[e_1] = r_1\), 对每个 \(e_1\) 分别求其子树里(自然不包括 \(e_1\)) \(col[x] = r_2\) 的节点 \(x\) 的数量, 最后全加起来。
- 枚举 \(e_2\) 满足 \(col[e_2] = r_2\), 对每个 \(e_2\) 分别求其到根的路径上 (自然不包括 \(e_2\)) \(col[x] = r_2\) 的节点 \(x\) 的数量, 最后全加起来。
由于 \(R\) 很小, 可以开一个桶, 配合 dfs 就可以实现 \(O(1)\) 回答节点 \(x\) 到根的路径上有多少个节点的颜色为 \(r\); 当然也可以实现 \(O(1)\) 回答节点 \(x\) 的子树内有多少个节点的颜色为 \(r\) (这个在实现上还要容斥一下)。
两种方法都需要明确 \(r\), 所以对于一个询问 \((r_1,r_2)\):
1.用第一种计算方式, 给颜色 \(r_1\) 挂上 \(r_2\), 每次 dfs 到 \(col[x] = r_1\) 的 \(x\) 都查询一次, 结果加到到对应询问的答案数组里。
2.用第一种计算方式, 给颜色 \(r_2\) 挂上 \(r_1\), 每次 dfs 到 \(col[x] = r_2\) 的 \(x\) 都查询一次, 结果加到到对应询问的答案数组里。
所以处理一个询问 \((r_1,r_2)\), 用第一种计算方式的时间复杂度是 \(O(num[r_1])\), 第二种则是 \(O(num[r_2])\)。
对于一个询问, 一个自然的想法是哪种复杂度小就交给哪种。
这个策略的局限性是不能处理两种复杂度都大的情况。
然而其实并不需要考虑处理两种复杂度都大的情况。
设立一个阈值 \(T\), 对于 \(num[r_2] \le T\) 的询问, 用第二种算法, 复杂度是 \(O(qT)\), \(q\) 与 \(n\) 同阶, 复杂度可看成 \(O(nT)\) ; 剩下的都交给第一种算法, 复杂度看上去是 \(O(qn)\) 即 \(O(n^2)\) 的, 但是由于这样的询问的数量是 \(O(\lfloor \frac{n}{T} \rfloor)\) 的 ,如果对询问去重, 就能保证每种这样的询问(按 \(r_2\) 分类)最多会被挂到 \(O(n)\) 个节点上, 这样, 复杂度就是 \(O(n \lfloor \frac{n}{T} \rfloor)\) 的了。
为分析方便, 把这两种复杂度加起来, 得到一个不太紧的上界 \(O(nT + n\lfloor \frac{n}{T} \rfloor)\), 对 \(T\) 的升降都会使得加号的两边一个升一个降, 故加号两边相等时, 渐进上界最低, 为 \(O(n\sqrt n)\)。
一般来说, 这样的复杂度式子 \(O(aT + \lfloor \frac{b}{T} \rfloor)\) 中, 若 \(a、b\) 不可自选而 \(T\) 可以自选, 那么取 \(aT = \lfloor \frac{b}{T} \rfloor\) 解出 \(T\) 来就可以让渐进上界最低, 这样的式子, 或者说这样的思想, 就叫 【根号平衡】。(大概)
话说这道题好像不去重也能过
#include<bits/stdc++.h>
using namespace std;
const int B = 453;
const int N = 200003;
const int R = 25003;
int n,q,r, color[N], T;
int ct, hd[N], nt[N<<1], vr[N<<1];
int num[R];
int r1[N], r2[N], Ans[N];
vector<int> ques[R], ques2[R];
int t1[R], t2[R];
void dfs1(int x) {
for(int i=0;i<(int)ques[color[x]].size();++i) {
int id = ques[color[x]][i];
Ans[id] += t1[r1[id]];
}
++t1[color[x]];
for(int i=hd[x];i;i=nt[i]) {
int y = vr[i];
dfs1(y);
}
--t1[color[x]];
}
void dfs2(int x) {
for(int i=0;i<(int)ques2[color[x]].size();++i) {
int id = ques2[color[x]][i];
Ans[id] -= t2[r2[id]];
}
for(int i=hd[x];i;i=nt[i]) {
int y = vr[i];
dfs2(y);
}
for(int i=0;i<(int)ques2[color[x]].size();++i) {
int id = ques2[color[x]][i];
Ans[id] += t2[r2[id]];
}
++t2[color[x]];
}
void ad(int x,int y) { vr[++ct] = y; nt[ct] = hd[x]; hd[x] = ct; }
int main() {
scanf("%d%d%d", &n, &r, &q);
T = sqrt(n*1.0);
scanf("%d", &color[1]);
++num[color[1]];
for(int i=2;i<=n;++i) {
int fa;
scanf("%d%d", &fa, &color[i]);
ad(fa, i);
++num[color[i]];
}
for(int i=1; i<=q; ++i) {
scanf("%d%d", &r1[i], &r2[i]);
if(num[r2[i]] <= T) ques[r2[i]].push_back(i);
else ques2[r1[i]].push_back(i);
}
dfs1(1);
dfs2(1);
for(int i=1; i<=q; ++i) cout << Ans[i] << '\n';
return 0;
}
题意简述:
给出数列 a[1~n], \(n \in [1, 3e5]\) 和若干次询问, 每次询问形如 \((x,y)\), 要求输出 \(a[x] + a[x+y] + a[x+2y] + \cdots + a[x+ky]\), 满足 \(x+ky \le n\) 且 \(x+(k+1)y > n\), 询问总数不超过 \(3e5\) 。
时空限制 \(4s - 70mb\)
跟上面那题差不多, 不做了。
再一道例题
推荐用 \(\text{virtual judge}\) 交。(这里)
题意简述:
给一段长度为 \(n \in [1, 300]\) 的 \(0/1\) 串和一个正整数 \(M\), 规定一次操作可以将一个位置取反或者将一段长度为 \(M\) 倍数的前缀取反, 问最少需要多少次操作才能使这个串变成最小循环节长度为 \(M\) 的循环串。
最小循环节长度为 \(M\) 的循环串:对于任意 \(i\), 如果 \(i+M \in [1,n]\), 那么 \(i\) 和 \(i+M\) 位置上的字符应该相等。
(例子: \(00100100\) 是个最小循环节为 \(3\) 的循环串)
解题的关键是 \(循环节长度 * 循环节个数 \approx n\), 那么这两个数值总有一个不超过 \(\sqrt n\), 分别对两种情况设计算法。
具体见参考资料《根号算法—-不只是分块》。
更多根号!
其实这节只有1道例题, 还是王悦同论文里的题orz
[JSOI2013互测 烧桥计划 BZOJ5424]
然而 bzoj 没了, 只能口胡啦。
题目描述:
给一个长度为 \(N \in [1,100000]\) 的序列 \(\{A_i\}\), 其中 \(A_i \in [1000,2000]\), 再给定一个 \(M \in [0,2e8]\)。
可以选若干个数(那自然可以不选), 记为 \(A_{p_1} \cdots A_{p_k}\), 满足 \(\{p_i\}\) 是个递增序列, 产生 \(A_{p_1} + 2A_{P_2} + 3A_{p_3} + \cdots + kA_{p_k}\) 的代价; 去掉选出来的数, 剩下的数下标不变, 可以看到剩下的数组成了若干连续的段, 定义每段的权 \(T\) 为这段所有 \(A\) 的和, 每个 \(T > M\) 的段都会产生 \(T\) 的代价。
求代价最小的选数方案所产生的代价。
时限 \(7s\)。
可以动态规划, 还能单调队列优化, 最终动态规划的时空复杂度为 \(O(N^2)\), 不细述。
解题的关键就是抓住 \(A_i\) 的下界, 分析最多选多少个数才可能成为最优解(最优解上界是一个数都不选的情况), 分析出来最多选 \(O(\sqrt N)\), 动态规划的时空复杂度就降为 \(O(N\sqrt N)\) 了。