link
顺带一提这是我第一道没看题解做出来的黑（也是第四道黑）。
写完看了一圈题解，我想说：
欸不是凭啥我不用卡常啊？
前言
这篇题解的复杂度是这样的：
小 \(p\) \(O(q \sqrt n \log \sqrt n + n \sqrt V)\)，大 \(p\) \(O (\sqrt V \log n)\)。
没卡常，也没有把 \(\log\) 调到下面什么的，过了。写完后到是卡了卡，暂时在最优解第一页。
正文
首先把值域看成一条直线，我们发现查询的位置的总数直接和 \(p\) 相关，是 \(\lfloor \frac Vq \rfloor\) 次，容易想到根号分治，以 \(\sqrt V\) 作为分治边界。
对于 \(p > \sqrt V\)，发现查询的值很少，可以直接存下每一个值的出现位置，存成一个个序列，然后在这些序列上二分，就可以得到答案。
这里给出实现：
vector<int> pos[V]; // 每一个值的序列// 查询
inline int query_ma(int l, int r, int vl, int vr, int p, int x) {int que = (vl - x + p - 1) / p * p + x, res = 0;while(que <= vr) {if(pos[que].size()) res += upper_bound(pos[que].begin(), pos[que].end(), r) - lower_bound(pos[que].begin(), pos[que].end(), l);que += p;} return res;
}......
......
//（main 里面）存储
for(int i = 1; i <= n; i ++) pos[in(a[i])].push_back(i);
对于 \(p \le \sqrt V\)，可以对着序列分块，然后直接强行预处理某块内对模数 \(p\) 取模得数为 \(b\) 的值，全都压到一个 vector 里面，查询的时候仍旧二分查找，不过这次二分的内容是值域。
然后就发现会 MLE，很凄惨，所以干脆就分治边界开小一点，序列分块块长开大一点，让暴力多跑一点，复杂度是不纯粹了，不过还是能过的。
这一步实现比较长，一会看完整代码吧。
然后是一些卡常技巧，毕竟一会要放的是我卡过常数的代码。
首先是 vector 的插入的常数非常大，大概是因为要动态分配内存，所以考虑先跑一遍你要插的数，求出每一个 vector 的大小，然后先 reverse 一下，就会飞快。
然后是查询，一般人都会散块跑暴力对吧，这是对的，但是可以优化，可以比较一个块左右端点和查询位置的距离，只跑小的那一边，如果跑的不是我们想要的，就加上整块，容斥一下，这样可以把（普通分块的）查询从最劣 \(3\sqrt n\) 做成 最劣 \(2\sqrt n\)，会快很多，在这里因为整块查询是带 \(\log\) 的，所以算距离的时候要带上查整块的代价，会更快一点。
再然后是我看最上面和我做法（应该）一样的那个题解，\(p\) 小的部分他对每一块都 sort 了，而这一步显然可以通过使插入的数字提前有序而省去。
再再然后是注意操作的空间要连续，不然大概会慢，没试，我一开始写空间就是连续的。
最后是玄学调块长，很奇怪但是值域的分治边界改成 \(100\) 会快到飞起（作为对比我一开始是 \(200\)）。
完整代码
// code by 樓影沫瞬_Hz17
#include <bits/stdc++.h>
using namespace std;#define getc() getchar_unlocked()
#define putc(a) putchar_unlocked(a)
#define en_ putc('\n')
#define e_ putc(' ')using pii = pair<int, int>;template<class T> inline T in() { T n = 0; char p = getc();while(p < '-') p = getc();bool f = p == '-' ? p = getc() : 0;do n = n * 10 + (p ^ 48), p = getc();while(isdigit(p));return f ? -n : n;
}
template<class T> inline T in(T &a) { return a = in<T>(); }
template<class T, class ... Args> inline void in(T &t, Args&... args) { in(t), in(args...); }template<class T> inline void out(T n) {if(n < 0) putc('-'), n = -n;if(n > 9) out(n / 10);putc(n % 10 + '0');
}template<class T1, class T2> T1 max(T1 a, T2 b) { return a > b ? a : a = b;}
template<class T1, class T2> T1 min(T1 a, T2 b) { return a < b ? a : a = b;}constexpr int N = 1e5 + 10, B = 370, T = N / B + 10, V = 2e5 + 10, D = 100, M = N / D + 10;int n, a[N], ans, q;
bool type;vector<int> pos[V];int L[T], R[T], bel[N];
// 大p的查询
inline int query_ma(int l, int r, int vl, int vr, int p, int x) {int que = (vl - x + p - 1) / p * p + x, res = 0; // que 表示要查的位置，计算方式比较烂while(que <= vr) {if(pos[que].size()) res += upper_bound(pos[que].begin(), pos[que].end(), r) - lower_bound(pos[que].begin(), pos[que].end(), l);que += p;} return res;
}int sz[D][D][T];
vector<int> sum[D][D][T]; // 写到这发现刚好是 DDT 给我笑喷了
// sum[i][j][k] 指在 k 块内对 i 取模为 j 的数
inline int que_mi(vector<int>&q, int vl, int vr) { if(q.empty()) return 0; // 这个是 p 小的时候对整块的查询，用得多，兴许我不写成函数会快？我懒return upper_bound(q.begin(), q.end(), vr) - lower_bound(q.begin(), q.end(), vl);
}
// 下面是对小 p 的查询
inline int query_mi(int l, int r, int vl, int vr, int p, int x, vector<int> *sm) { int ql = bel[l], qr = bel[r], res = 0;if(qr == ql) { // 同一块其实也能用我讲得那个优化，不过我懒for(int i = l; i <= r; i ++) if(a[i] % p == x) res += (a[i] <= vr and a[i] >= vl);return res; } if(R[ql] - l - 14 < l - L[ql]) { // 令 14 作为整块查询的代价，比较是正着快还是容斥快for(int i = l; i <= R[ql]; i ++) // 正着跑if(a[i] % p == x) res += (a[i] <= vr and a[i] >= vl);} else { res += que_mi(sm[ql], vl, vr); // 容斥for(int i = L[ql]; i < l; i ++) if(a[i] % p == x)res -= (a[i] <= vr and a[i] >= vl);} if(r - L[qr] - 14 < R[qr] - r) { // 同上for(int i = L[qr]; i <= r; i ++) if(a[i] % p == x)res += (a[i] <= vr and a[i] >= vl);} else { res += que_mi(sm[qr], vl, vr);for(int i = r + 1; i <= R[qr]; i ++) if(a[i] % p == x)res -= (a[i] <= vr and a[i] >= vl);} // 整块我没法优化了for(int i = ql + 1; i < qr; i ++) res += que_mi(sm[i], vl, vr);return res;
} struct num { int id, val; };
num b[N]; // 辅助数组inline void get(int &x) { x ^= type ? ans : 0;}signed main() { #ifndef ONLINE_JUDGE freopen("私は雨.in", "r", stdin);freopen("私は雨.out", "w", stdout);#endif in(n, type);for(int i = 1; i <= n; i ++) pos[in(a[i])].push_back(i);for(int i = 1; i <= n; i ++) { b[i].id = i;b[i].val = a[i];} sort(b + 1, b + 1 + n, [](num a, num b) { return a.val < b.val;});// 排序，然后就不用最后每个块重排了for(int i = 1, j; R[i - 1] != n; i ++) { L[i] = (i - 1) * B + 1, R[i] = min(n, i * B); for(j = L[i]; j <= R[i]; j ++) bel[j] = i;} for(int p = 1; p < D; p ++) for(int i = 1; i <= n; i ++) sz[p][a[i] % p][bel[i]] ++; // 预先算 size for(int p = 1; p < D; p ++) for(int j = 0; j < p; j ++) for(int i = 1; R[i - 1] != n; i ++) sum[p][j][i].reserve(sz[p][j][i]); // 然后 reservefor(int p = 1; p < D; p ++) for(int i = 1; i <= n; i ++) sum[p][b[i].val % p][bel[b[i].id]].emplace_back(b[i].val);// 如果不这样做的话会慢死的，预处理 TLE 了解一下in(q);for(int i = 1, l, r, L, R, p, x; i <= q; i ++) { in(l, r, L, R, p, x);get(l), get(r), get(L), get(R), get(p), get(x);ans = p >= D ? query_ma(l, r, L, R, p, x) : query_mi(l, r, L, R, p, x, sum[p][x]);out(ans), en_;}
}
// 星間~ 干渉~ 融解~ 輪迴~ 邂逅~ 再生~ ララバイ~
