Trees |

树上背包

Sat, 22 Jun 2024 15:11:24 +0000

选取 m 个结点

这是最普遍的情况, 从树中选取 \(m\) 个结点, 最大化它们的价值之和.

符合直觉地, 设 \(f_{u, i}\) 表示从以 \(u\) 为根的子树中选取了 \(i\) 个结点的最大价值之和. 转移是显然的:

\[ f_{u, i + j} = \max\{f_{u, i} + f_{v, j}\} \]

其中 \(i\), \(j\) 的范围应当分别为 \(u\) 此前枚举的子树大小和, 以 \(v\) 为根的子树大小.

其最优性和可行性都是显然的, 我们考虑这个算法的复杂度. 看起来似乎是 \(\Theta(n^{3})\), 但事实上对于任意点对 \((i \in S_{u}, j \in S_{v})\), 它只会在 \(u\) 处被枚举一次. 于是时间复杂度实际上是 \(\Theta(n^{2})\).

选取结点的代价之和至多为 m

在这个问题中为每个结点引入了代价, 此时上述的复杂度分析不再适用.

我们不妨考虑换一种思路, 正常的 \(0/1\) 背包复杂度之所以为 \(\Theta(nm)\), 是因为每次只需要对一个物品做是否选取的决策. 在这里, 我们同样考虑将物品独立起来, 只考虑当前物品选或不选. 为了保证无后效性, 接下来的结点编号都被重新设为其在后序遍历中的时间戳.

设 \(f_{i, j}\) 表示考虑了前 \(i\) 个物品, 背包大小为 \(j\), 能取到的最大价值和.

若选该物品, 则可以选择它子树中的物品, \(f_{i, j} \leftarrow f_{i - 1, j - w_{i}} + v_{i}\).
若不选该物品, 则它子树内的物品都不可以选, 而子树中的编号恰好是连续的, 于是 \(f_{i, j} \leftarrow f_{i - siz_{i}, j}\).

这样转移时间复杂度即为 \(\Theta(nm)\).

int n, m, dfn;
std::vector<std::vector<int>> E, f;
std::vector<int> w, v, siz;

void dfs (int u) {
 for (int v : E[u]) dfs(v), siz[u] += siz[v];
 dfn++;
 for (int j = 0; j <= m; j++) {
 f[dfn][j] = f[dfn - siz[u]][j];
 if (j >= w[u]) f[dfn][j] = std::max(f[dfn][j], f[dfn - 1][j - w[u]] + v[u]);
 }
}

int knapsack_on_tree () {
 siz = std::vector<int>(n + 1, 1);
 f = std::vector<std::vector<int>>(n + 2, std::vector<int>(m + 1));
 dfs(0);
 return f[n + 1][m];
}

「Codechef」Children Trips

Sat, 24 Jun 2023 11:00:56 +0000

Description

你在一颗树上旅行。

树由 \(n\) 个点，\(n - 1\) 条边构成，每条边的长度 \(w\) 是 \(1\) 或 \(2\)。

你要从点 \(u\) 沿着唯一的简单路径走到点 \(v\)。但是，你的体力有限，所以一天之内最多只能走 \(l\) 的距离。一天结束时待在树的节点外是很危险的，所以你必须在一天结束前到达某个节点并停下（可以刚好到达），即使你没有走到 \(l\) 的距离。

给定这棵树和 \(q\) 个询问，每个询问给出 \(u,v,l\)，请求出至少需要多少天。

数据范围 : \(1 \leqslant n,q \leqslant 10^{5}, 1 \leqslant x,y,u,v \leqslant n,w \in \{1, 2\}, 2 \leqslant l \leqslant 2n.\)

Tutorial

Lemma1: 一条路径，正着走和倒着走答案是一样的。

Proof1: 考虑将正着和倒着每天累计走的距离写下来，容易发现正着走相当于一开始落后了至多 \(1\) 的距离，后面在不断追赶。可以发现在走的过程中是存在单调性的，所以正着走一定不可能超过倒着走，但也不可能落后超过 \(1\)。由于最后会走到相同的位置，所以答案是一样的。

有了上述引理，我们就可以考虑分别计算 \(u\) 和 \(v\) 分别跳到 \(\textrm{LCA}(u, v)\) 下面最高能跳到的点的答案。设 \(l_{1}, l_{2}\) 分别表示 \(u\) 和 \(v\) 剩下的距离，最终答案即为 \(u\) 和 \(v\) 的答案之和加上 \(\left\lceil\frac{l_{1} + l_{2}}{l}\right\rceil\)。

考虑对询问根号分治，分别处理 \(l \leqslant \sqrt{n}\) 的询问和 \(l \gt \sqrt{n}\) 的询问。

对于 \(l \gt \sqrt{n}\) 的询问，可以发现其跳的次数不超过 \(\sqrt{n}\)，于是可以直接暴力跳，用倍增维护一下即可。
对于 \(l \leqslant \sqrt{n}\) 的询问，可以预处理出从每个点 \(u\) 开始，此时的 \(l = k\)，往上跳 \(2^{i}\) 天到的点 \(f_{u, k, i}\)，倍增往上跳即可。

时间复杂度 \(\Theta(n \sqrt{n} \log n)\)，卡一卡常可以通过。

考虑换一种思路，我们给树上 \(\sqrt{n}\) 个点打上标记，称它们为特殊点。那么如果标记打得足够均匀，就可以使 \(u, v \to \textrm{LCA}(u, v)\) 的路径上每隔 \(\sqrt{n}\) 的距离经过一个特殊点，且总共经过 \(\sqrt{n}\) 个特殊点。至于如何打标记，可以记 \(dis_{u}\) 表示 \(u\) 到树上最远点的距离，取 \(B = \sqrt{n}\)，\(u\) 为标记点当且仅当 \(B | dis_{u}\)。

考虑预处理 \(f_{u, k}\) 表示当 \(l = k\) 时，从 \(u\) 开始走一天到的点（如果这个点超过了 \(u\) 祖先中最深的特殊点，那么就将 \(f_{u, k}\) 设为该特殊点，并且计算剩下了多少距离），\(g_{u, k}\) 表示当 \(l = k\) 时，从 \(u\) 开始走到 \(u\) 祖先中最深的特殊点需要花费的天数。

容易发现，由于走到 \(u\) 祖先中最深的特殊点最多 \(2\sqrt{n}\) 的距离，所以 \(k\) 的取值范围为 \([0, 2\sqrt{n}]\)。预处理直接从上往下递推即可，由于状态总数是 \(n \sqrt{n}\) 的，所以预处理时间复杂度也是 \(\Theta(n \sqrt{n})\)。至于如何使用这两个数组优化往上跳的过程则是简单的，不作赘述。

总时间复杂度 \(\Theta(n \sqrt{n})\)，可以轻松通过此题。

虚树

Sat, 24 Jun 2023 11:00:56 +0000

虚树

在一些问题中，我们只关心关键点的信息，同时我们需要维护他们之间的树形结构，于是可以想到将它们和它们之间的 \(\rm LCA\) 拉出来建一颗树，这棵树就被称作虚树。

有一个朴素的想法，就是对它们两两求 \(\rm LCA\)，并且对求出的 \(\rm LCA\) 再求 \(\rm LCA\)，中途判重，最后按照祖先关系连边。

经过观察可以发现，我们只需要按照 \(\rm dfs\) 虚从小到大的顺序枚举每个点，将相邻两点求 \(\rm LCA\) 即可。具体来说，我们可以维护一个栈，这个栈中存的是当前点在虚树上的所有祖先。设当前栈顶为 \(v\)，对于新加入的结点 \(u\)，我们对它进行分类讨论：

若 \(\rm LCA(u,v)=v\)，那么直接将 \(u\) 入栈。
若 \(\rm LCA(u,v)\) 是栈中某个不为 \(v\) 的点，则弹栈直到 \(\rm LCA(u,v)\)，每弹一个就向栈中比它深度多 \(1\) 的结点连边，最后并把 \(u\) 入栈。
若 \(\rm LCA(u,v)\) 不在栈中，那么弹栈直到栈顶的 \(\rm dfs\) 序小于 \(\rm LCA(u,v)\) 的 \(\rm dfs\) 序，每弹一个就向栈中比它深度多 \(1\) 的结点连边，并把最后一个弹出的结点向 \(\rm LCA(u,v)\) 连边，最后把 \(\rm LCA(u,v)\) 和 \(u\) 入栈。

不难发现这样一定是对的，并且设关键点数量为 \(k\)，则虚树内点数不超过 \(2k\)。

在一棵有 \(n\) 个点的树上建立一颗有 \(k\) 个点的虚树的时间复杂度为 \(\Theta(k\log n)\)。

经典例题

[SDOI2011] 消耗战

首先有一个暴力 \(\rm DP\)，设 \(dp_{u}\) 表示将 \(u\) 的子树内所有关键点与 \(u\) 的联系断开所需要的最小代价。转移时枚举 \(u\) 的所有子节点，分类讨论：

若 \(v\) 为关键点，那么必须切断这条边，有 \(dp_{u}=dp_{u}+w_{u,v}\)
若 \(v\) 不为关键点，那么可以切断这条边也可以从 \(dp_{v}\) 转移，故有 \(dp_{u}=dp_{u}+min\{dp_{v},w_{u,v}\}\)

最终答案就是 \(dp_{1}\)，这个暴力的时间复杂度是 \(\Theta(qn)\)。

观察到 \(\sum k\leqslant 5e5\)，所以考虑对每次询问建虚树。

建虚树之前需要记 \(M_{u}\) 表示从 \(1\) 到 \(u\) 的路径上最短的边权，因为只需要切掉最短的边权就可以让点 \(u\) 与 \(1\) 不连通，而切上面的边是更优的，所以可以用 \(M_{u}\) 直接替换转移方程中的 \(w_{u,v}\)。

时间复杂度 \(\Theta(\sum k\log n)\)。

[HEOI2014] 大工程

首先建虚树。

对于两两之间距离之和，可以计算每条边的贡献。
对于最大\(/\)最小值，可以树形 \(\rm DP\) 或点分治。

时间复杂度 \(\Theta(\sum k\log n)\)。

[SDOI2015] 寻宝游戏

我们发现如果将虚树建出来，那么答案就是虚树上所有边权之和的两倍。

于是我们考虑动态维护虚树的边权之和。先把所有点的 \(\rm dfs\) 序求出来，然后我们发现边权之和等于 \(\rm dfs\) 序相邻两点的距离之和加上最左边和最右边两点的距离，于是我们可以使用 \(\rm set\) 维护，树剖求 \(\rm LCA\)。

时间复杂度 \(\rm \Theta(n\log n)\)。

长链剖分

Sat, 24 Jun 2023 11:00:56 +0000

长链剖分

考虑将重儿子设为链最长的那一个，剖分是简单的，可以做到 \(\Theta(n).\)

这样剖分有一些性质：

链长和是 \(n\)，因为每个点都在且仅在一条链中。
任意点 \(x\) 的 \(k\) 级祖先 \(y\) 到它所在的长链底端距离不小于 \(k\) 。因为如果 \(x\) 和 \(y\) 在同一条长链上，那么 \(y\) 所在的长链长度不小于 \(k\) 。如果它们不在同一条的长链上，那么 \(y\) 到另一条长链底端的距离一定大于 \(k\)，否则的话 \(x\) 所在的链就可以接在 \(y\) 上成为更长的链。
从任意一个点开始跳重链的次数最多是 \(\sqrt{n}\) 级别的。因为容易知道每次跳到的长链长度一定大于当前链，于是最坏情况是分别经过了长度为 \(1, 2, 3, \cdots, \sqrt{n}\) 的长链，最多跳 \(\sqrt{n}\) 次。

Theta(n log n) - Theta(1) 算 k 级祖先

考虑预处理每个点的 \(2\) 的幂次级祖先，对于一次询问 \((u, k)\)，首先跳到 \(u\) 的 \(highbit(k)\) 级祖先 \(v\) 上，由长链剖分的性质可知，\(v\) 到其所在长链底端的距离不小于 \(highbit(k).\)

由于长链长度之和为 \(n\)，所以我们可以预处理每条链顶端节点的 \(l\) 级祖先，\(l\) 取遍不大于链长的所有整数。并且我们还可以存下每条链的所有节点，挂在链顶。

这样，对于一次询问，假设 \(v\) 的 \(k - higtbit(k)\) 级祖先不超过链顶，那么可以直接查询，否则也可以从链顶跳若干步得到。由于 \(k - highbit(k) \lt hightbit(k)\)，故其一定小于链长，要查询的祖先是预处理过的。

时间复杂度 \(\Theta(n \log n)\) 预处理，单次查询 \(\Theta(1)\)。