模拟赛中遇到了这个题,当时我这个沙雕因为把一个\(y\)打成了\(x\)而爆零。回来重新写这道题,莫名其妙的拿了rank1。。。

我的解法与其他几位的题解有些不同我太蒻了。并没有选取所谓的关键点,而是用树链剖分将树上问题转化为序列的问题。


序列问题的解决

  • 现在的问题是,维护一个序列,要求查询若干个区间的并集的权值种类和\(mex\),无修改操作。
  • 如果只有一个区间,那么这个问题就可以很愉快的用主席树解决了。
  • 然而要查询的是区间并的权值种类和\(mex\),而且这两个东西都不满足区间可加性,于是可以放弃线段树的思路了。
  • 可以想到用分块解决这个问题,设每一块大小为\(B\)
  • 考虑到点权\(\leq 30000\),又要合并若干个区间,于是可以想到用\(bitset\)维护区间权值信息。
  • 设\(f[][]\)为一个\(bitset\)的二维数组,\(f[l][r]\)表示从第\(l\)块到第\(r\)块(包含\(l,r\))之间的权值集合,这个数组可以在\(O(n\frac{30000}{32})\)的时间内预处理出来。每次查询的时候,整块的信息可以在\(O(\frac{30000}{32})\)的时间内解决。
  • 剩余的部分直接暴力处理,时间复杂度为\(O(B)\)。这样单次查询可以做到\(O(\frac{30000}{32}+B)\)
  • 至于区间并,直接开一个全局变量记录答案(我的代码中用的是\(cur\)),依次处理每个区间。因为重叠的部分并不会对答案有影响。现在序列的问题已经解决了。

序列处理部分的代码

int b[N]; // 记录区间上每一个位置属于哪个块
int L[N], R[N]; // 每个块的左右断点
bitset<W> cur; // 查询时用到的全局变量
bitset<W> f[110][110]; // 预处理的 f 数组 void preWork() {
// 预处理
for (int i = 1; i <= n; ++i) {
// 先计算单个块的权值情况
b[i] = (i-1) / B + 1;
f[b[i]][b[i]].set(a[i]);
}
// 处理每个块的左右端点
for (int i = 1; i <= b[n]; ++i)
L[i] = R[i-1] + 1, R[i] = i * B;
R[b[n]] = n; // 最后一个块的右端点要特判
for (int i = 1; i < b[n]; ++i)
for (int j = i+1; j <= b[n]; ++j) // 计算 f 数组
f[i][j] = f[i][j-1] | f[j][j];
} void queryOnBlock(int l, int r) {
if (b[l] == b[r]) {
// 特判左右端点在同一个块内的情况
for (int i = l; i <= r; ++i) cur.set(a[i]);
return;
}
cur |= f[b[l]+1][b[r]-1]; // 两块之间的部分直接查询
for (int i = l; i <= R[b[l]]; ++i) cur.set(a[i]); // 左边的剩余部分
for (int i = L[b[r]]; i <= r; ++i) cur.set(a[i]); // 右边的剩余部分
} int mex(bitset<W> &s) {
// 暴力求 mex
for (int i = 0; i < W; ++i)
if (!s.test(i)) return i;
return 1e9;
}

将树上问题转化为序列问题

树链剖分的板子(我这个蒟蒻写挂的部分)。。。

直接贴代码了

int G[N], ed = 1, w[N]; // 树的存储
struct Edge {
int to, nxt;
Edge() { to = nxt = 0; }
Edge(int to, int nxt) : to(to), nxt(nxt) {}
} e[N<<1]; inline void addEdge(int x, int y) {
e[++ed] = Edge(y, G[x]), G[x] = ed;
e[++ed] = Edge(x, G[y]), G[y] = ed;
} // 树链剖分相关
int dfn[N]; // dfs 序
int fa[N]; // 父结点
int son[N]; // 重儿子
int top[N]; // 重链顶端
int size[N]; // 子数大小
int dep[N]; // 深度
int a[N]; // 转化的序列 void dfs1(int x, int p) {
size[x] = 1, fa[x] = p;
for (int i = G[x]; i != 0; i = e[i].nxt) {
int y = e[i].to;
if (y == p) continue;
dep[y] = dep[x] + 1;
dfs1(y, x);
size[x] += size[y];
if (size[son[x]] < size[y])
son[x] = y;
}
} void dfs2(int x, int t) {
static int cur = 0;
dfn[x] = ++cur, a[cur] = w[x], top[x] = t;
if (!son[x]) return;
dfs2(son[x], t);
for (int i = G[x]; i != 0; i = e[i].nxt) {
int y = e[i].to;
if (y == son[x] || y == fa[x]) continue;
dfs2(y, y);
}
} void queryOnTree(int x, int y) {
// 树上查询
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
queryOnBlock(dfn[top[x]], dfn[x]);
x = fa[top[x]];
}
if (dfn[x] > dfn[y]) swap(x, y);
queryOnBlock(dfn[x], dfn[y]);
}

总代码

// 2598ms 57.76MB 无O2
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <bitset>
#define LL long long
using namespace std; inline int getint() {
int x = 0, f = 1; char c = getchar();
while (!isdigit(c)) { if (c == '-') f = 0; c = getchar(); }
while (isdigit(c)) { x = (x*10) + (c-'0'); c = getchar(); }
return f ? x : -x;
} const int N = 1e5 + 10;
const int B = 1e3;
const int W = 30001; int n, m, flag; // flag 判断是否需要异或
int ans1, ans2, lastans; // ans1 为权值种类,ans2 为权值 mex int G[N], ed = 1, w[N]; // 树的存储
struct Edge {
int to, nxt;
Edge() { to = nxt = 0; }
Edge(int to, int nxt) : to(to), nxt(nxt) {}
} e[N<<1]; inline void addEdge(int x, int y) {
e[++ed] = Edge(y, G[x]), G[x] = ed;
e[++ed] = Edge(x, G[y]), G[y] = ed;
} // 树链剖分相关
int dfn[N]; // dfs 序
int fa[N]; // 父结点
int son[N]; // 重儿子
int top[N]; // 重链顶端
int size[N]; // 子数大小
int dep[N]; // 深度
int a[N]; // 转化的序列 void dfs1(int x, int p) {
size[x] = 1, fa[x] = p;
for (int i = G[x]; i != 0; i = e[i].nxt) {
int y = e[i].to;
if (y == p) continue;
dep[y] = dep[x] + 1;
dfs1(y, x);
size[x] += size[y];
if (size[son[x]] < size[y])
son[x] = y;
}
} void dfs2(int x, int t) {
static int cur = 0;
dfn[x] = ++cur, a[cur] = w[x], top[x] = t;
if (!son[x]) return;
dfs2(son[x], t);
for (int i = G[x]; i != 0; i = e[i].nxt) {
int y = e[i].to;
if (y == son[x] || y == fa[x]) continue;
dfs2(y, y);
}
} int b[N]; // 记录区间上每一个位置属于哪个块
int L[N], R[N]; // 每个块的左右断点
bitset<W> cur; // 查询时用到的全局变量
bitset<W> f[110][110]; // 预处理的 f 数组 void preWork() {
// 预处理
for (int i = 1; i <= n; ++i) {
// 先计算单个块的权值情况
b[i] = (i-1) / B + 1;
f[b[i]][b[i]].set(a[i]);
}
// 处理每个块的左右端点
for (int i = 1; i <= b[n]; ++i)
L[i] = R[i-1] + 1, R[i] = i * B;
R[b[n]] = n; // 最后一个块的右端点要特判
for (int i = 1; i < b[n]; ++i)
for (int j = i+1; j <= b[n]; ++j) // 计算 f 数组
f[i][j] = f[i][j-1] | f[j][j];
} void queryOnBlock(int l, int r) {
if (b[l] == b[r]) {
// 特判左右端点在同一个块内的情况
for (int i = l; i <= r; ++i) cur.set(a[i]);
return;
}
cur |= f[b[l]+1][b[r]-1]; // 两块之间的部分直接查询
for (int i = l; i <= R[b[l]]; ++i) cur.set(a[i]); // 左边的剩余部分
for (int i = L[b[r]]; i <= r; ++i) cur.set(a[i]); // 右边的剩余部分
} void queryOnTree(int x, int y) {
// 树上查询
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
queryOnBlock(dfn[top[x]], dfn[x]);
x = fa[top[x]];
}
if (dfn[x] > dfn[y]) swap(x, y);
queryOnBlock(dfn[x], dfn[y]);
} int mex(bitset<W> &s) {
// 暴力求 mex
for (int i = 0; i < W; ++i)
if (!s.test(i)) return i;
return 1e9;
} int main() {
cin >> n >> m >> flag;
for (int i = 1; i <= n; ++i) w[i] = getint();
for (int i = 1; i < n; ++i) {
int x = getint(), y = getint();
addEdge(x, y);
}
dfs1(1, 0), dfs2(1, 1);
preWork();
for (int i = 1; i <= m; ++i) {
cur.reset();
int num = getint();
for (int j = 1; j <= num; ++j) {
int x = getint() ^ (flag*lastans);
int y = getint() ^ (flag*lastans);
queryOnTree(x, y);
}
ans1 = cur.count(), ans2 = mex(cur);
lastans = ans1 + ans2;
printf("%d %d\n", ans1, ans2);
}
return 0;
}

[题解] 洛谷 P3603 雪辉的更多相关文章

  1. 题解 洛谷P5018【对称二叉树】(noip2018T4)

    \(noip2018\) \(T4\)题解 其实呢,我是觉得这题比\(T3\)水到不知道哪里去了 毕竟我比较菜,不大会\(dp\) 好了开始讲正事 这题其实考察的其实就是选手对D(大)F(法)S(师) ...

  2. 题解 洛谷 P3396 【哈希冲突】(根号分治)

    根号分治 前言 本题是一道讲解根号分治思想的论文题(然鹅我并没有找到论文),正 如论文中所说,根号算法--不仅是分块,根号分治利用的思想和分块像 似却又不同,某一篇洛谷日报中说过,分块算法实质上是一种 ...

  3. 题解-洛谷P5410 【模板】扩展 KMP(Z 函数)

    题面 洛谷P5410 [模板]扩展 KMP(Z 函数) 给定两个字符串 \(a,b\),要求出两个数组:\(b\) 的 \(z\) 函数数组 \(z\).\(b\) 与 \(a\) 的每一个后缀的 L ...

  4. 题解-洛谷P4229 某位歌姬的故事

    题面 洛谷P4229 某位歌姬的故事 \(T\) 组测试数据.有 \(n\) 个音节,每个音节 \(h_i\in[1,A]\),还有 \(m\) 个限制 \((l_i,r_i,g_i)\) 表示 \( ...

  5. 题解-洛谷P4724 【模板】三维凸包

    洛谷P4724 [模板]三维凸包 给出空间中 \(n\) 个点 \(p_i\),求凸包表面积. 数据范围:\(1\le n\le 2000\). 这篇题解因为是世界上最逊的人写的,所以也会有求凸包体积 ...

  6. 题解-洛谷P4859 已经没有什么好害怕的了

    洛谷P4859 已经没有什么好害怕的了 给定 \(n\) 和 \(k\),\(n\) 个糖果能量 \(a_i\) 和 \(n\) 个药片能量 \(b_i\),每个 \(a_i\) 和 \(b_i\) ...

  7. 题解-洛谷P5217 贫穷

    洛谷P5217 贫穷 给定长度为 \(n\) 的初始文本 \(s\),有 \(m\) 个如下操作: \(\texttt{I x c}\),在第 \(x\) 个字母后面插入一个 \(c\). \(\te ...

  8. 题解 洛谷 P2010 【回文日期】

    By:Soroak 洛谷博客 知识点:模拟+暴力枚举 思路:题目中有提到闰年然后很多人就认为,闰年是需要判断的其实,含有2月29号的回文串,前四位是一个闰年那么我们就可以直接进行暴力枚举 一些小细节: ...

  9. 题解 洛谷P2158 【[SDOI2008]仪仗队】

    本文搬自本人洛谷博客 题目 本文进行了一定的更新 优化了 Markdown 中 Latex 语句的运用,加强了可读性 补充了"我们仍不曾知晓得 消失的 性质5 ",加强了推导的严谨 ...

随机推荐

  1. java中的序列化问题

    序列化就是一种用来处理对象流的机制,所谓对象流也就是将对象的内容进行流化,将数据分解成字节流,以便存储在文件中或在网络上传输.可以对流化后的对象进行读写操作,也可将流化后的对象传输于网络之间.序列化是 ...

  2. C#中Array类

    Array类是C#中所有数组的基类,它是在System命名空间中定义的,Array类提供了各种用于数组的属性和方法

  3. spring cloud gateway 之限流篇

    转载请标明出处: https://www.fangzhipeng.com 本文出自方志朋的博客 在高并发的系统中,往往需要在系统中做限流,一方面是为了防止大量的请求使服务器过载,导致服务不可用,另一方 ...

  4. CUBE,ROLLUP 和 GROUPING

    1.用 CUBE 汇总数据 CUBE 运算符生成的结果集是多维数据集.多维数据集是事实数据的扩展,事实数据即记录个别事件的数据.扩展建立在用户打算分析的列上.这些列被称为维.多维数据集是一个结果集,其 ...

  5. ABAP术语-Update Task

    Update Task 原文:http://www.cnblogs.com/qiangsheng/archive/2008/03/20/1114184.html Part of an ABAP pro ...

  6. TopJUI Combobox 联动

    这里给联动进行一个简单定义:因Combobox选择或输入的值发生改变时对自身或者其它组件产生影响称为联动.(注:editable确定是否可以手动输入) 有两种实现方法: 一.自己写对应的onChang ...

  7. filter 图片滤镜的各种设置

    filter 图片滤镜 给当前元素加滤镜_改变它的明亮度 定义:filter 属性定义了元素(通常是<img>)的可视效果(例如:模糊与饱和度).作用在图片上或元素上.div{ },或 d ...

  8. Redis 4.0.X版本reshard出现错误的解决办法

    原文链接:https://my.oschina.net/juluking/blog/1606222 原作者的版本是Redis 4.0.6,我的版本是4.0.8,所以猜测是否所有4.0.x版本都有此问题 ...

  9. ILOVEYOU代码

    代码确实很简单...我是初学者,练手的. /* 文件名: Love.c 描 述: 打印字母和图形 */ #include<stdio.h> #include<windows.h> ...

  10. Oracle入门第六天(下)——高级子查询

    一.概述 主要内容: 二.子查询介绍 1.简单子查询(WHERE子查询) SELECT last_name FROM employees WHERE salary > (SELECT salar ...