虚树

在给定的树上问题中，树的大小过大，导致总时间复杂度$O(nq)$不能被接受，但是有很多点在查询的过程中根本用不到，所以对于每一个查询，建立一个小的查询树，在这个小树上求解问题。这个小树就是虚树。

LuoguP2495 - [SDOI2011] 消耗战

题目链接

如果只要一组数据，那么可以通过$dp$进行求解。

从树的叶子结点向根节点$dp$：

如果当前这个节点是关键点，那么这个点必然要被删掉，那么一定是将这个点连带着以这个节点为根节点的子树一并删除，即一定是一刀切。但是不一定只删除这一个子树，也可以连带着上面的点一起删。为了让代价最小，就选择从整棵树的根节点到这个点的路径上代价最小的边删即可。

如果这个点不是关键点，那么可以选择删除这个点，此时代价和上面的情况一样；也可以选择不删除这个点，而是把其子节点删除。子节点是已经$dp$算好的最优结果，所以遍历每一个子节点，计算删除代价即可。（如果这个子节点的子树下没有关键点，那么$dp$后的结果自然是$0$）。

这样从下往上跑一次$dp$，根节点的答案就是这道题目的答案。

但是这道题目$O(nq)$不能接受，我们要考虑优化。优化的思路是，我们发现在有些查询当中，有些点是根本不必要的，比如说有几个连续的非关键点，那么这个点的贡献就是传递答案，把这些点删除显然不影响答案。那么我们可以在每次查询中，将关键点单独拎出来做一棵子树，然后跑上述$dp$即可。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 500005;
const LL INF = 1e18;LL en1, en, n, k, m, si, tot;
//si：栈的当前元素个数
LL front[N], front1[N], a[N], dep[N], fa[N][22], lg[N];
LL stk[N], id[N], mp[N], dp[N], vis[N];
//dep[N]：树上节点的深度（求LCA用）
//fa[N][22]：距离为2的幂数的祖先（求LCA用）
//lg[N]：以2为底的对数
//stk[N]：构建虚树时要用的栈
//id[N]：所有节点的dfs序
//mp[N]：从根节点到这个节点的路径中最小的边权
//dp[N]：存储从下至上删除当前节点的子树内所有关键点的最小代价
//vis[N]：用来存储这个点是不是关键点struct Edge {LL v, w, next;
}e1[N * 2], e[N * 2];//对每一次查询建的虚树
void addEdge(int u, int v) {e[++en] = {v, 0, front[u]};front[u] = en;
}//总体的树
void addEdge1(int u, int v, int w) {e1[++en1] = {v, w, front1[u]};front1[u] = en1;
}void dfs(int u, int f) {//获取所有节点的dfs序id[u] = ++tot;//获取深度dep[u] = dep[f] + 1;fa[u][0] = f;//倍增获取祖先信息for (int i = 1; (1 << i) <= dep[u]; ++i) {fa[u][i] = fa[fa[u][i - 1]][i - 1];}for (int i = front1[u]; i; i = e1[i].next) {LL v = e1[i].v, w = e1[i].w;if (v != f) {//更新根节点到u路径上的最小边权mp[v] = min(mp[u], w);dfs(v, u);}}
}//构建虚树时使用，求最近公共祖先(LCA)
int lca(int x, int y) {if (dep[x] < dep[y]) swap(x, y);while (dep[x] > dep[y]) x = fa[x][lg[dep[x] - dep[y]]];if (x == y) return x;for (int k = lg[dep[x]]; k >= 0; --k) {if (fa[x][k] != fa[y][k]) {x = fa[x][k]; y = fa[y][k];}	}return fa[x][0];
}//建立虚树
void build_virtual_tree() {//将关键点按照原题中的树的dfs序进行排列sort(a + 1, a + m + 1, [](const int &A, const int &B) {return id[A] < id[B];});//将根节点推入栈中stk[++si] = 1;front[1] = 0;for (int i = 1; i <= m; ++i) {if (a[i] == 1) continue;//g为a[i]和当前栈顶节点的LCAint g = lca(a[i], stk[si]);//如果LCA不是栈顶节点，说明当前节点进入了其中一个祖先的新的子树//需要将当前栈中原来子树的节点处理掉if (g != stk[si]) {while (id[g] < id[stk[si - 1]]) {//依次建边，并弹出栈addEdge(stk[si - 1], stk[si]);--si;}//如果LCA的dfs序大于栈顶第二个节点的dfs序//说明LCA点不是当前栈顶节点的祖先//不是的需要先推入栈，然后再连边if (id[g] > id[stk[si - 1]]) {front[g] = 0;addEdge(g, stk[si]);stk[si] = g;}else {addEdge(g, stk[si--]);}}front[a[i]] = 0;stk[++si] = a[i];}//栈中剩余的节点都是一条链上的for (int i = 1; i < si; ++i) {addEdge(stk[i], stk[i + 1]);}
}void dfs1(int u) {//如果当前节点是叶子节点if (front[u] == 0) {if (vis[u]) dp[u] = mp[u];else dp[u] = 0;front[u] = vis[u] = 0;return;} //tmp：如果u不是关键点，则统计删除自己所有子树的最小贡献，记为tmpLL tmp = 0;for (int i = front[u]; i; i = e[i].next) {LL v = e[i].v;dfs1(v);tmp += dp[v];}//如果u是关键节点，则只能一刀切，将以u为根节点的子树一并摘除//删除从根节点到u的路径上最短的一条//如果u不是关键点，则可以选择一刀切，也可以选择用tmp，取其中的最小if (vis[u]) dp[u] = mp[u];else dp[u] = min(mp[u], tmp);//求dp对每个节点只访问一次，所以可以直接把状态清空//现在清空可以避免对于每组数据统一清空，时间复杂度变回O(nq)front[u] = 0;vis[u] = 0;
}void main2() {cin >> n;lg[1] = 0; lg[2] = 1;for (int i = 3; i <= n; ++i) {lg[i] = lg[i / 2] + 1;}en1 = 0;for (int i = 1; i <= n; ++i) {front1[i] = id[i] = 0;mp[i] = INF;}for (int i = 1; i < n; ++i) {LL u, v, w;cin >> u >> v >> w;addEdge1(u, v, w);addEdge1(v, u, w); }tot = 0;mp[1] = INF; dfs(1, 0);cin >> k;for (int i = 1; i <= k; ++i) {cin >> m;for (int j = 1; j <= m; ++j) {cin >> a[j];vis[a[j]] = 1;}si = en = 0;build_virtual_tree();dfs1(1);cout << dp[1] << '\n';}
}int main() {ios::sync_with_stdio(false);cin.tie(0); cout.tie(0);LL _ = 1;
//	cin >> _while (_--) main2();return 0;
}