给你一棵 \(n\) 个节点且带点权的树，\(m\) 个询问，每个询问给你多条链，请你输出这几条链的点的集合并的颜色数和 mex。
强制在线。
\(1\leq n \leq 10^5,1\leq m\leq 3 \times 10^4\)。
sol
首先如果不强制在线，用树上莫队即可。
但多了个强制在线，容易想到是预处理题。
查询链颜色数，比较好的一种方法是使用 bitset，对值域建 bitset，答案就是 bitset 中 \(1\) 的数量。
对于 mex，在 bitset 上暴力找第一个为 \(0\) 的位即可。
那么现在的问题就是怎么把一条路径上的 bitset 并起来。
法一
考虑树分块。
考虑用一种简单的树分块技巧——树上撒点。
简单来说就是先设一个阈值 \(S\)，在树上选择不超过 \(\frac{n}{S}\) 个点作为关键点，满足每个关键点到离它最近的祖先关键点的距离不超过 \(S\)。
具体地，每次选择当前深度最大的一个非关键点，若它的 \(1 \sim S\) 级祖先都不是关键点，则把它的 \(S\) 级祖先标记为关键点。
由于上述方法中每标记一个关键点，至少有 \(S\) 个点不会被标记，所以关键点的数量是正确的。
仔细思考，容易发现每个关键点到离它最近的祖先关键点的距离不超过 \(S\) 这个条件也满足。
撒完关键点，再记录两关键点间的 bitset，先用 \(\mathcal O(S)\) 的时间求出相邻两关键点的 bitset，再处理出两两之间的即可，预处理总时间复杂度为 \(\mathcal O(\frac{n^2}{S}+\frac{n^3}{wS^2})\)。
然后考虑询问，此时询问的路径就被拆成了两个散块和一个整块，散块暴力，整块 bitset 取交集即可，总时间复杂度为 \(\mathcal O(mS+\frac{nm}{w})\)。
取 \(S=\sqrt n\)，则总时间复杂度为 \(\mathcal O((n+m)\sqrt n+\frac{n^2+nm}{w})\)，可过。
\(\text{5.05s / 346.17MB / 4.14KB C++20 O2}\)。
#include <cstdio>
#include <bitset>
#include <algorithm>
using namespace std;
namespace Fread
{
const int SIZE = 1 << 23;
char buf[SIZE], *S, *T;
inline char getchar()
{
if (S == T)
{
T = (S = buf) + fread(buf, 1, SIZE, stdin);
if (S == T)
return '\n';
}
return *S++;
}
}
namespace Fwrite
{
const int SIZE = 1 << 23;
char buf[SIZE], *S = buf, *T = buf + SIZE;
inline void flush()
{
fwrite(buf, 1, S - buf, stdout);
S = buf;
}
inline void putchar(char c)
{
*S++ = c;
if (S == T)
flush();
}
struct NTR
{
~NTR()
{
flush();
}
} ztr;
}
#ifdef ONLINE_JUDGE
#define getchar Fread::getchar
#define putchar Fwrite::putchar
#endif
inline int read()
{
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9')
{
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
{
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
inline void write(int x)
{
if (x < 0)
{
putchar('-');
x = -x;
}
if (x > 9)
write(x / 10);
putchar(x % 10 + '0');
}
const int _ = 2e5 + 7;
bitset<_> bt[202][202], nw;
int n, m, B, kkk, a[_], fa[_], dep[_], mxd[_], FF[_], siz[_], tp[_], hson[_];
int id[_], cnt, head[_], tot, ans, ans1, ans2, sta[_], top, gg[_];
struct edge
{
int to, nxt;
} e[_ << 1];
void dfs1(int now, int D)
{
siz[now] = 1;
dep[now] = D;
mxd[now] = dep[now];
for (int i = head[now]; i; i = e[i].nxt)
{
int v = e[i].to;
if (!dep[v])
{
fa[v] = now;
dfs1(v, D + 1);
siz[now] += siz[v];
if (mxd[v] > mxd[now])
mxd[now] = mxd[v];
if (siz[hson[now]] < siz[v])
hson[now] = v;
}
}
if (mxd[now] - dep[now] >= 1000)
id[now] = ++tot, mxd[now] = dep[now];
}
void dfs2(int now)
{
for (int i = head[now]; i; i = e[i].nxt)
{
int v = e[i].to;
if (dep[v] > dep[now])
{
if (id[v])
{
int ip = id[sta[top]], in = id[v];
for (int x = v; x != sta[top]; x = fa[x])
bt[ip][in].set(a[x]);
nw = bt[ip][in];
for (int i = 1; i < top; ++i)
{
bitset<_> &bs = bt[id[sta[i]]][in];
bs = bt[id[sta[i]]][ip];
bs |= nw;
}
FF[v] = sta[top], gg[v] = gg[sta[top]] + 1;
sta[++top] = v;
}
dfs2(v);
if (id[v])
--top;
}
}
}
void dfs3(int now, int tf)
{
tp[now] = tf;
if (hson[now])
dfs3(hson[now], tf);
for (int i = head[now]; i; i = e[i].nxt)
{
int v = e[i].to;
if (!tp[v])
dfs3(v, v);
}
}
inline int LCA(int x, int y)
{
while (tp[x] != tp[y])
{
if (dep[tp[x]] < dep[tp[y]])
swap(x, y);
x = fa[tp[x]];
}
return dep[x] < dep[y] ? x : y;
}
inline int mex(bitset<_> &s)
{
for (int i = 0; i < _; ++i)
if (!s.test(i)) return i;
return 1e9;
}
signed main()
{
n = read(), m = read(), kkk = read();
for (int i = 1; i <= n; ++i)
a[i] = read();
for (int i = 1, u, v; i < n; ++i)
{
u = read(), v = read();
e[++cnt] = (edge) {v, head[u]}, head[u] = cnt;
e[++cnt] = (edge) {u, head[v]}, head[v] = cnt;
}
dfs1(1, 1);
if (!id[1])
id[1] = ++tot;
sta[top = 1] = gg[1] = 1;
dfs2(1);
dfs3(1, 1);
int z, u, v;
while (m--)
{
z = read();
nw.reset();
while(z--)
{
u = read(), v = read();
if(kkk) u ^= ans, v ^= ans;
int l = LCA(u, v);
while (u != l && !id[u])
nw.set(a[u]), u = fa[u];
while (v != l && !id[v])
nw.set(a[v]), v = fa[v];
if (u != l)
{
int pre = u;
while (dep[FF[pre]] >= dep[l])
pre = FF[pre];
if (pre != u)
nw |= bt[id[pre]][id[u]];
while (pre != l)
nw.set(a[pre]), pre = fa[pre];
}
if (v != l)
{
int pre = v;
while (dep[FF[pre]] >= dep[l])
pre = FF[pre];
if (pre != v)
nw |= bt[id[pre]][id[v]];
while (pre != l)
nw.set(a[pre]), pre = fa[pre];
}
nw.set(a[l]);
}
ans1 = nw.count(), ans2 = mex(nw);
write(ans1), putchar(' '), write(ans2), putchar('\n');
ans = ans1 + ans2;
}
return 0;
}
法二
考虑轻重链剖分，询问时将路径上的若干条重链的 bitset 并起来即可。
由于重链上的点的 dfn 序是连续的，序列分块即可。
每次询问，跳重链分块计算这条重链的贡献即可。
时间复杂度为 \(\mathcal O(\frac{n^2}{w}+m\log n(\sqrt{n}+\frac{n}{w}))\)。
最优解。
\(\text{1.43s / 56.70MB / 3.61KB C++20 O2}\)。
#include <cstdio>
#include <bitset>
#define re register
namespace Fread
{
const int SIZE = 1 << 23;
char buf[SIZE], *S, *T;
inline char getchar()
{
if (S == T)
{
T = (S = buf) + fread(buf, 1, SIZE, stdin);
if (S == T)
return '\n';
}
return *S++;
}
}
namespace Fwrite
{
const int SIZE = 1 << 23;
char buf[SIZE], *S = buf, *T = buf + SIZE;
inline void flush()
{
fwrite(buf, 1, S - buf, stdout);
S = buf;
}
inline void putchar(char c)
{
*S++ = c;
if (S == T)
flush();
}
struct NTR
{
~NTR()
{
flush();
}
} ztr;
}
#ifdef ONLINE_JUDGE
#define getchar Fread::getchar
#define putchar Fwrite::putchar
#endif
inline int read()
{
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9')
{
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
{
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
inline void write(int x)
{
if (x < 0)
{
putchar('-');
x = -x;
}
if (x > 9)
write(x / 10);
putchar(x % 10 + '0');
}
const int _ = 1e5 + 7, W = 3e4 + 7, B = 1e3;
std::bitset<W> f[102][102], nw;
int n, m, kkk, cnt_node, ans1, ans2, ans, tot, a[_], fa[_], dep[_], siz[_], hson[_], top[_], dfn[_], b[_], bel[_], L[_], R[_], head[_], to[_ << 1], nxt[_ << 1];
inline void swap(int &x, int &y)
{
x ^= y ^= x ^= y;
}
inline int mex(std::bitset<W> &s)
{
for (re int i = 0; i < W; ++i)
if (!s.test(i)) return i;
return 1e9;
}
inline void add(int u, int v)
{
to[++tot] = v;
nxt[tot] = head[u];
head[u] = tot;
}
void dfs1(int u, int D)
{
dep[u] = D, siz[u] = 1;
for(re int i = head[u]; i; i = nxt[i])
{
re int v = to[i];
if(siz[v]) continue;
fa[v] = u;
dfs1(v, D + 1);
siz[u] += siz[v];
if(siz[hson[u]] < siz[v]) hson[u] = v;
}
}
void dfs2(int u, int tf)
{
top[u] = tf, dfn[u] = ++cnt_node, a[cnt_node] = b[u];
if(!hson[u]) return;
dfs2(hson[u], tf);
for(re int i = head[u]; i; i = nxt[i])
{
re int v = to[i];
if(top[v]) continue;
dfs2(v, v);
}
}
inline void pre()
{
for (re int i = 1; i <= n; ++i)
{
bel[i] = (i - 1) / B + 1;
f[bel[i]][bel[i]].set(a[i]);
}
for (re int i = 1; i <= bel[n]; ++i)
L[i] = R[i - 1] + 1, R[i] = i * B;
R[bel[n]] = n;
for (re int i = 1; i < bel[n]; ++i)
for (re int j = i + 1; j <= bel[n]; ++j)
f[i][j] = f[i][j - 1] | f[j][j];
}
inline void Query_on_block(int l, int r)
{
if (bel[l] == bel[r])
{
for (re int i = l; i <= r; ++i) nw.set(a[i]);
return;
}
nw |= f[bel[l] + 1][bel[r] - 1];
for (re int i = l; i <= R[bel[l]]; ++i) nw.set(a[i]);
for (re int i = L[bel[r]]; i <= r; ++i) nw.set(a[i]);
}
inline void Query_on_tree(int u, int v)
{
while(top[u] != top[v])
{
if(dep[top[u]] < dep[top[v]]) swap(u, v);
Query_on_block(dfn[top[u]], dfn[u]);
u = fa[top[u]];
}
if(dep[u] > dep[v]) swap(u, v);
Query_on_block(dfn[u], dfn[v]);
}
signed main()
{
n = read(), m = read(), kkk = read();
for(re int i = 1; i <= n; ++i) b[i] = read();
for(re int i = 1, u, v; i < n; ++i)
{
u = read(), v = read();
add(u, v), add(v, u);
}
dfs1(1, 1), dfs2(1, 1);
pre();
while(m--)
{
nw.reset();
re int tmp = read();
while(tmp--)
{
re int u = read() ^ (kkk * ans), v = read() ^ (kkk * ans);
Query_on_tree(u, v);
}
ans1 = nw.count(), ans2 = mex(nw);
write(ans1), putchar(' '), write(ans2), putchar('\n');
ans = ans1 + ans2;
}
}