【题解】P5355 [Ynoi2017] 由乃的玉米田

题意

P4688 [Ynoi2016] 掉进兔子洞

给定一个长为 $n$ 的序列和 $m$ 个操作，每次操作询问区间 $[l, r]$ 内是否可以选出两个数 $a_x, a_y$，使得：

1. $a_x - a_y = x$

2. $a_x + a_y = x$

3. $a_x \cdot a_y = x$

4. $\min(a_x, a_y) \mid \max(a_x, a_y)$ 且 $\frac{\max(a_x, a_y)}{\min(a_x, a_y)} = x$

$n, m \leq 10^5, 0 \leq x \leq 10^5, 1 \leq a_i \leq 10^5$

思路

莫队 + bitset + 根号分治。

bitset 的基本用法

P3674 小清新人渣的本愿 的强化版。

不用修改，不强制在线，考虑 莫队 处理。

不妨令 $N$ 为某一极大值，同时维护两个 bitset $s1, s2$，其中 $s1$ 表示值 $x$ 是否在当前区间内出现过，$s2$ 表示值 $N - x$ 是否在当前区间内出现过。

对于操作 $1$，如果 $[l, r]$ 内存在 $a - b = x$，因为 $b$ 可以表示成 $a - x$，所以 $[l, r]$ 内也一定存在 $a, a - x$，则问题转化成：是否可以在 $[l, r]$ 内选出 $a$ 使得 $[l, r]$ 内同时存在 $a, a - x$，可以用 s1[a] == s1[a - x] == true 判断。不难发现上面的代码等价于 (s1 & (s1 << x)).any()。

对于操作 $2$，回顾 $s2$ 的定义，发现 (s2 >> (N - x))[i] 实际上维护的是 $[l, r]$ 内是否存在 $(N - i) - (N - x) = x - i$。故而我们可以用 (s1 & (s2 >> (N - x))).any() 判断 $[l, r]$ 内是否存在 $a + b = x$。由于 bitset 不能维护负数下标，$N$ 应该取到 $10^5$ 及以上。

对于操作 $3$，因为 $0 \leq x \leq 10^5$，所以可以暴力枚举 $x$ 的因数并用 $s1$ 判断。

对于操作 $4$，发现难以直接用莫队维护。令 $[l, r]$ 中的最大值为 $k$，因为当 $x \geq \sqrt{k}$ 时，暴力枚举商为 $x$ 的两个数复杂度是 $\mathcal{O}(\sqrt{n})$，所以可以考虑 根号分治。

当 $x \geq \sqrt{k}$ 时，暴力枚举商为 $x$ 的两个数即可。

当 $x < \sqrt{k}$ 时，考虑 $\mathcal{O}(n\sqrt{n})$ 预处理答案。令 $a_i$ 的最大值为 $K$，不妨对于 $1 \leq x < \sqrt{K}$ 预处理 $p_i$，$p_i = l$ 表示 $[l, i]$ 内存在 $\frac{a}{b} = x$ 且 $i - l$ 最小。对于询问 $[l, r]$ 内是否存在 $\frac{a}{b} = x$，显然若 $l \leq p_r$ 则存在，反之则不存在。

莫队部分时间复杂度 $\mathcal{O}(n \sqrt{n})$，根号分治时间复杂度 $\mathcal{O}(n \sqrt{n})$，因此总时间复杂度 $\mathcal{O}(n \sqrt{n})$。

代码

view code#include <cstdio>
#include <cmath>
#include <cstring>
#include <vector>
#include <bitset>
#include <algorithm>
using namespace std;

#define rint register int

inline int read(){
    rint x=0,c=getchar();
    for(;c<48||c>57;c=getchar());
    for(;c>47&&c<58;c=getchar())x=x*10+(c^48);
    return x;
}

const int maxn = 1e5 + 5;

int n, m;
int maxv, len;
int lst[maxn], pre[maxn];
int a[maxn], bel[maxn], cnt[maxn];
bool ans[maxn];
bitset<maxn> s1, s2;

struct node {
	int l, r, x, opt, id;
	
	node(): l(), r(), x(), opt(), id() {}
	
	node(int _l, int _r, int _x, int _opt, int _id): l(_l), r(_r), x(_x), opt(_opt), id(_id) {}
	
	bool operator < (const node& rhs) const {
		if (bel[l] ^ bel[rhs.l]) {
			return bel[l] < bel[rhs.l];
		}
		return (bel[l] & 1 ? r < rhs.r : r > rhs.r);
	}
} q1[maxn];

vector<node> q2[maxn];

inline void add(rint x) {
	cnt[a[x]]++;
	if (cnt[a[x]] == 1) {
		s1[a[x]] = true;
		s2[maxv - a[x]] = true;
	}
}

inline void del(rint x) {
	cnt[a[x]]--;
	if (!cnt[a[x]]) {
		s1[a[x]] = false;
		s2[maxv - a[x]] = false;
	}
}

int main() {
	rint opt, l, r, x, tmp;
	rint left = 0, right = 0;
	n = read(), m = read();
	rint block = sqrt(n);
	for (rint i = 1; i <= n; i++) {
		a[i] = read();
		maxv = max(maxv, a[i] + 1);
		bel[i] = (i - 1) / block + 1;
	}
	block = sqrt(maxv);
	for (rint i = 1; i <= m; i++) {
		opt = read(), l = read(), r = read(), x = read();
		if ((opt == 4) && (x < block)) {
			q2[x].push_back(node(l, r, x, opt, i));
		} else {
			len++;
			q1[len] = node(l, r, x, opt, i);
		}
	}
	sort(q1 + 1, q1 + len + 1);
	for (rint i = 1; i <= len; i++) {
		while (left > q1[i].l) {
			add(--left);
		}
		while (right < q1[i].r) {
			add(++right);
		}
		while (left < q1[i].l) {
			del(left++);
		}
		while (right > q1[i].r) {
			del(right--);
		}
		if (q1[i].opt == 1) {
			ans[q1[i].id] = (s1 & (s1 << q1[i].x)).any();
		} else if (q1[i].opt == 2) {
			ans[q1[i].id] = (s1 & (s2 >> (maxv - q1[i].x))).any();
		} else if (q1[i].opt == 3) {
			for (rint j = 1; j * j <= q1[i].x; j++) {
				if (q1[i].x % j == 0) {
					if (s1[j] && s1[q1[i].x / j]) {
						ans[q1[i].id] = true;
						break;
					}
				}
			}
		} else {
			for (rint j = 1; q1[i].x * j <= maxv; j++) {
				if (s1[j] && s1[q1[i].x * j]) {
					ans[q1[i].id] = true;
					break;
				}
			}
		}
	}
	for (rint i = 1; i < block; i++) {
		if (!q2[i].size()) {
			continue;
		}
		memset(lst, 0, (maxv + 1) * sizeof(int));
		memset(pre, 0, (n + 1) * sizeof(int));
		for (rint j = 1; j <= n; j++) {
			pre[j] = pre[j - 1];
			lst[a[j]] = j;
			tmp = a[j] * i;
			if (tmp <= maxv) {
				pre[j] = max(pre[j], lst[tmp]);
			}
			tmp = a[j] / i;
			if (a[j] % i == 0) {
				pre[j] = max(pre[j], lst[tmp]);
			}
		}
		for (rint j = 0; j < q2[i].size(); j++) {
			ans[q2[i][j].id] = (q2[i][j].l <= pre[q2[i][j].r]);
		}
	}
	for (rint i = 1; i <= m; i++) {
		putchar('y'), putchar('u');
		if (ans[i]) {
			putchar('n'), putchar('o');
		} else {
			putchar('m'), putchar('i');
		}
		putchar('\n');
	}
	return 0;
}