Nobody is needed

赛时没看 F,写完 E 就没时间了，唉唉，唉唉唉唉。

思路是 t 宝的代码。

Solution

考虑只有一组询问 $l=1,r=n$ 的时候怎么做。

此时显然可以 dp，设 $f_i$ 为以 $a_i$ 结尾的合法子序列的个数。

得到方程

$$f_i=1+\sum _{a_j\mid a_i}{f}_j$$

$1$ 是子序列中只有自己的情况。

答案即为 $\sum f_i$。

对于原问题，考虑扫描线。

发现枚举 $r$ 的话不是很好维护 dp 数组，因为对于每个 $l$ 的 dp 数组是不一样的，所以这里枚举 $l$。

假设此时枚举到 $l$，那所有 $d{p}_i$ 的值是 $[l+1,i]$ 区间内以 $i$ 结尾的合法子序列的数量。

将 $f_l$ 初始化为 $1$。

如果直接按之前那样枚举的话，复杂度会炸到 $n^2$。考虑 $a_l$ 能影响到的数只有 $a_l$ 的倍数，考虑每次只枚举这些数。

这些数每个会有一个增量，根据之前的 dp，发现增量也可以 dp 算出来，只需要将方程改成 $f_i=\sum _{a_j\mid a_i}{f}_i$ 即可。

优化这个过程，可以通过先枚举 $a_l$ 的倍数，假设是 $k$，此时 $k$ 的增量已经被算出，再枚举 $k$ 的倍数 $k^{\prime }$ 让 $k^{\prime }$ 的增量加上 $k$ 的增量，就能够保证 $a_l$ 的所有倍数能够算出增量。

算出增量后，用树状数组维护 $f$ 数组的区间和即可。

一轮枚举倍数是 $O(n\ln n)$ 的，要枚举所有倍数的倍数即为 $O(n{\ln }^{2}n)$，用树状数组让所有倍数加上增量是 $O(n\ln n\log n)$ 的，所以总复杂度为 $O(n{\log }^{2}n)$。

struct BIT {
	int n;
	vector<ll> c;

	BIT(int _n) {
		n = _n;
		c.resize(n + 1, 0);
	}

	void add(int x, int v) {
		for (; x <= n; x += x & -x) c[x] += v;
	}

	ll query(int x) {
		ll res = 0;
		for (; x; x -= x & -x) res += c[x];
		return res;
	}

	ll query(int l, int r) {
		l --;
		return query(r) - query(l);
	}
};

void solve() {
	int n, m;
	cin >> n >> m;
	vector<int> a(n + 1), p(n + 1);
	for (int i = 1; i <= n; i ++) {
		cin >> a[i];
		p[a[i]] = i;
	}
	
	vector<vector<pair<int, int>>> qry(n + 1);
	for (int i = 1; i <= m; i ++) {
		int l, r;
		cin >> l >> r;
		qry[l].emplace_back(r, i);
	}

	vector<ll> ans(m + 1);
	vector<ll> g(n + 1);
	BIT bit(n);

	for (int l = n; l >= 1; l --) {
		int x = a[l];
		g[x] = 1;
		for (int i = x; i <= n; i += x) {
			if (p[i] < p[x]) continue;
			for (int j = i + i; j <= n; j += i) {
				if (p[j] < p[i]) continue;
				g[j] += g[i];
			}
		}
		for (int i = x; i <= n; i += x) {
			if (p[i] < p[x]) continue;
			bit.add(p[i], g[i]);
			g[i] = 0;
		}
		for (auto [r, id] : qry[l]) ans[id] = bit.query(r);
	}
	for (int i = 1; i <= m; i ++) cout << ans[i] << " \n"[i == m];
}