【洛谷5398】[Ynoi2018]GOSICK（二次离线莫队）
题目：
当我刚学莫队的时候，他们告诉我莫队能解决几乎所有区间问题；
现在，当我发现一个区间问题似乎难以用我所了解的莫队解决的时候，他们就把这题的正解叫做 XXX 莫队。——题记
（以上皆为瞎扯，纯属虚构，请勿当真）
分析：
先转化一下题目：如果允许每次询问都暴力把区间扫一遍，那么每扫到一个数 \(i\) ，就统计已经扫过的部分中有多少个 \(j\) 满足 \(a_j\) 是 \(a_i\) 的因数（即取数对 \((i,j)\) ）或倍数 （即取数对 \((j,i)\) ）。注意，因为 \((i,j)\) 和 \((j,i)\) 是不同的，如果 \(a_i=a_j\) ，那么答案要加 \(2\) 。
考虑莫队。每次往当前区间加入或删除一个元素的时候，需要统计当前区间有多少个元素是该元素的因数或倍数（为了和题目中的「询问」区分，我们不妨把这个操作简称为一个数对一个区间「统计」），然后给答案加上或减去这个数量。这样单次修改的复杂度是 \(O(n)\) ，总时间复杂度高达 \(O(n^2\sqrt{n})\) 。 GG
黑科技来了 ：由于每次当前区间两端点的移动是已知的，所以我们把两端点移动时出现的「统计」离线下来处理（是谓「二次离线」）。
如何离线呢？我们发现每次都是一个数 \(a\) 对一个区间 \([l,r]\) 统计，而这个操作又可以拆分为对 \([1,l)\) 和 \([1,r]\) 两个前缀统计。
然后开始大力分类讨论 ……
第一，当左端点从 \(l\) 左移到 \(l'\) 时，是每个 \(i\in[l',l)\) 对 \([i,r]\) 统计，即对 \([1,i)\) 和 \([1,r]\) 统计；
第二，当左端点从 \(l\) 右移到 \(l'\) 时，是每个 \(i\in[l,l')\) 对 \([i,r]\) 统计，即对 \([1,i)\) 和 \([1,r]\) 统计；
第三，当右端点从 \(r\) 左移到 \(r'\) 时，是每个 \(i\in(r',r]\) 对 \([l,i]\) 统计，即对 \([1,l)\) 和 \([1,i]\) 统计；
第四，当右端点从 \(r\) 右移到 \(r'\) 时，是每个 \(i\in(r,r']\) 对 \([l,i]\) 统计，即对 \([1,l)\) 和 \([1,i]\) 统计。
可以看出统计分为两大类。第一类是 \(i\) 对于 \([1,i)\) （或 \([1,i]\) ，但很明显这两个差距很小）统计，第二类是一个区间中的 \(i\) 对一个固定的前缀分别统计（如第一种情况中是所有 \(i\in[l',l)\) 对固定的前缀 \([1,r]\) 统计）。
第一类可以预处理。第二类可以按前缀从小到大排序，暴力扫当前前缀对应的所有统计（根据莫队的复杂度证明，端点移动距离之和是 \(O(n\sqrt{n})\) ）。
事实上这两类统计可以抽象成同一个问题：维护一个结构，支持「插入一个数」和「给定 \(k\) ，查询已经插入的数中有多少个是 \(k\) 的因数或倍数」。插入次数是 \(O(n)\) ，查询次数是 \(O(n\sqrt{n})\) 。
既然查询次数远比插入次数多，自然考虑维护每个数的答案。插入一个数时，因为可以在 \(O(\sqrt{n})\) 时间内遍历一个数的所有因数，所以直接暴力修改所有因数的答案即可。同理，当 \(k\) 大于一个阈值，比如 \(S\) ，倍数也可以暴力修改，单次时间复杂度不超过 \(O(\frac{n}{S})\) ，据说此处选择 \(S=32\) 。
那么当 \(k\leq S\) 怎么办呢？这里有一个很巧妙的做法。预处理出每个数能否被 \([1,S]\) 中的某个数整除（这个结果下称「状态」），并将结果压成一个 \(S\) 位的二进制数，并开一个大小为 \(2^S\) 的桶记录「这个状态的数的答案应该统一加上多少」。当插入 \(k(k\leq S)\) 时，暴力将所有 \(k\) 这一位上是 \(1\) 的状态的答案加 \(1\) 。查询时不光查询前一段话中维护的答案，也要加上这一段话中对应状态的答案。由于 \(2^{32}\) 太大了，因此把因数分成 \(8\) 个一组，每个数对应 \(4\) 个状态。这样插入时只需要修改 \(2^{8-1}\) 个状态，查询时需要查询这个数对应的 \(4\) 个状态。
还有一个小小的细节。由于默认任意两个相同的数会给答案贡献 \(2\) （原因在文首说了），如果 \(i\) 对 \([l,r]\) 统计，而 \(i\in[l,r]\) ，那么 \((i,i)\) 这个数对就被算了两次。没关系，我们只需要放任它算两次，最后给所有询问的答案减去区间长度即可。也由于这个原因，\(i\) 对 \([1,i]\) 统计的答案应该是 \(i\) 对 \([1,i)\) 统计的答案加 \(2\) 。
代码：
注意每次算出的是答案相对于上次的变化量，所以最后要按照处理询问的顺序做一遍前缀和。
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cctype>
#include <vector>
#include <cmath>
using namespace std;
namespace zyt
{
template<typename T>
inline bool read(T &x)
{
char c;
bool f = false;
x = 0;
do
c = getchar();
while (c != EOF && c != '-' && !isdigit(c));
if (c == EOF)
return false;
if (c == '-')
f = true, c = getchar();
do
x = x * 10 + c - '0', c = getchar();
while (isdigit(c));
if (f)
x = -x;
return true;
}
template<typename T>
inline void write(T x)
{
static char buf[20];
char *pos = buf;
if (x < 0)
putchar('-'), x = -x;
do
*pos++ = x % 10 + '0';
while (x /= 10);
while (pos > buf)
putchar(*--pos);
}
typedef long long ll;
const int N = 1e5 + 10, M = 1e5, Q = N, SS = 8, S = 32;
const bool ADD = true, SUB = false;
int n, m, block, blnum, belong[N], arr[N], fac[N][4], facnum[4][1 << SS], now[N], f[N];
ll ans[Q];
struct _ask
{
int l, r, id;
bool operator < (const _ask &b) const
{
return belong[l] == belong[b.l] ? r < b.r : belong[l] < belong[b.l];
}
}ask[Q];
struct node
{
int l, r, id;
bool type;
node(const int _l, const int _r, const int _id, const bool _t)
: l(_l), r(_r), id(_id), type(_t) {}
};
vector<node> v[N];
void insert(const int a)
{
for (int i = 1; i * i <= a; i++)
if (a % i == 0)
{
++now[i];
if (i * i < a)
++now[a / i];
}
if (a > S)
{
for (int i = a; i <= M; i += a)
if (i > S)
++now[i];
}
else
{
int bl = (a - 1) / SS, pos = (a - 1) % SS;
for (int i = 0; i < (1 << SS); i++)
if (i & (1 << pos))
++facnum[bl][i];
}
}
int query(const int a)
{
int ans = now[a];
for (int i = 0; i < 4; i++)
ans += facnum[i][fac[a][i]];
return ans;
}
int work()
{
read(n), read(m);
block = sqrt(n), blnum = ceil(double(n) / double(block));
for (int i = 1; i <= M; i++)
for (int j = 0; j < 4; j++)
for (int k = j * SS + 1; k <= (j + 1) * SS; k++)
if (i % k == 0)
fac[i][j] |= (1 << (k - j * SS - 1));
for (int i = 1; i <= n; i++)
read(arr[i]), belong[i] = (i - 1) / block + 1;
for (int i = 1; i <= m; i++)
read(ask[i].l), read(ask[i].r), ask[i].id = i;
sort(ask + 1, ask + m + 1);
for (int i = 1; i <= n; i++)
f[i] = query(arr[i]), insert(arr[i]);
for (int i = 1, l = 1, r = 1; i <= m; i++)
{
if (ask[i].l < l)
{
v[r].push_back(node(ask[i].l, l - 1, ask[i].id, ADD));
while (ask[i].l < l)
ans[ask[i].id] -= f[--l];
}
if (ask[i].l > l)
{
v[r].push_back(node(l, ask[i].l - 1, ask[i].id, SUB));
while (ask[i].l > l)
ans[ask[i].id] += f[l++];
}
if (ask[i].r > r)
{
v[l - 1].push_back(node(r + 1, ask[i].r, ask[i].id, SUB));
while (ask[i].r > r)
ans[ask[i].id] += f[++r] + 2;
}
if (ask[i].r < r)
{
v[l - 1].push_back(node(ask[i].r + 1, r, ask[i].id, ADD));
while (ask[i].r < r)
ans[ask[i].id] -= f[r--] + 2;
}
}
memset(facnum, 0, sizeof(facnum));
memset(now, 0, sizeof(now));
for (int i = 1; i <= n; i++)
{
insert(arr[i]);
for (vector<node>::iterator it = v[i].begin(); it != v[i].end(); it++)
for (int j = it->l; j <= it->r; j++)
ans[it->id] += query(arr[j]) * (it->type == ADD ? 1 : -1);
}
ans[0] = 2;
for (int i = 1; i <= m; i++)
ans[ask[i].id] += ans[ask[i - 1].id];
for (int i = 1; i <= m; i++)
ans[ask[i].id] -= ask[i].r - ask[i].l + 1;
for (int i = 1; i <= m; i++)
write(ans[i]), putchar('\n');
return 0;
}
}
int main()
{
#ifdef BlueSpirit
freopen("5398.in", "r", stdin);
#endif
return zyt::work();
}
