虚树
虚树
概念
大概就是在要做多次树形 dp 的时候，发现并不是所有点都用得到。也就是只有“关键点”才用得到。考虑在每次 dp 的时候，重新建一棵树，只有这些关键点。
把关键点拿出来，按照 dfs 序排序，用单调栈维护一条链，然后每次加点，建树。
例题
T1 洛谷 P2495 [SDOI2011]消耗战
题目描述
在一场战争中，战场由n个岛屿和n-1个桥梁组成，保证每两个岛屿间有且仅有一条路径可达。现在，我军已经侦查到敌军的总部在编号为1的岛屿，而且他们已经没有足够多的能源维系战斗，我军胜利在望。已知在其他k个岛屿上有丰富能源，为了防止敌军获取能源，我军的任务是炸毁一些桥梁，使得敌军不能到达任何能源丰富的岛屿。由于不同桥梁的材质和结构不同，所以炸毁不同的桥梁有不同的代价，我军希望在满足目标的同时使得总代价最小。
侦查部门还发现，敌军有一台神秘机器。即使我军切断所有能源之后，他们也可以用那台机器。机器产生的效果不仅仅会修复所有我军炸毁的桥梁，而且会重新随机资源分布（但可以保证的是，资源不会分布到1号岛屿上）。不过侦查部门还发现了这台机器只能够使用m次，所以我们只需要把每次任务完成即可。
输入输出格式
输入格式：
第一行一个整数n，代表岛屿数量。
接下来n-1行，每行三个整数u,v,w，代表u号岛屿和v号岛屿由一条代价为c的桥梁直接相连，保证1<=u,v<=n且1<=c<=100000。
第n+1行，一个整数m，代表敌方机器能使用的次数。
接下来m行，每行一个整数ki，代表第i次后，有ki个岛屿资源丰富，接下来k个整数h1,h2,…hk，表示资源丰富岛屿的编号。
输出格式：
输出有m行，分别代表每次任务的最小代价。
输入输出样例
输入样例#1：
10
1 5 13
1 9 6
2 1 19
2 4 8
2 3 91
5 6 8
7 5 4
7 8 31
10 7 9
3
2 10 6
4 5 7 8 3
3 9 4 6
输出样例#1：
12
32
22
说明
【数据规模和约定】
对于10%的数据，2<=n<=10,1<=m<=5,1<=ki<=n-1
对于20%的数据，2<=n<=100,1<=m<=100,1<=ki<=min(10,n-1)
对于40%的数据，2<=n<=1000,m>=1,sigma(ki)<=500000,1<=ki<=min(15,n-1)
对于100%的数据，2<=n<=250000,m>=1,sigma(ki)<=500000,1<=ki<=n-1
思路：考虑只有一次询问的话是一个非常简单的 dp。但是询问次数很多，可询问的总点数与 n 同阶，那么利用虚树，就可以做到 \(O(klog_2k)\)
看起来非常的 naive，但我抄代码还写了好久
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#define ll long long
#define maxn 250010
#define maxk 500010
#define INF 1000000000000000
using namespace std;
int n, m;
inline ll min(ll a, ll b, ll c){return min(a, min(b, c));}
struct Edge{
int to, next; ll w;
}e[maxn * 2], E[maxn * 2]; int c1, head[maxn], c2, Head[maxn];
inline void add_edge(int u, int v, ll w){
e[c1].to = v; e[c1].w = w;
e[c1].next = head[u]; head[u] = c1++;
}
inline void Add_edge(int u, int v, ll w){
E[c2].to = v; E[c2].w = w;
E[c2].next = Head[u]; Head[u] = c2++;
}
int f[maxn][21], id[maxn], c3, dep[maxn]; ll mn[maxn][21];
void dfs(int u, int fa){
id[u] = ++c3;
for(int i = head[u]; ~i; i = e[i].next){
int v = e[i].to; ll w = e[i].w; if(v == fa) continue;
dep[v] = dep[u] + 1; f[v][0] = u; mn[v][0] = w;
dfs(v, u);
}
}
void init_lca(){
for(int j = 1; j <= 20; ++j)
for(int i = 1; i <= n; ++i){
f[i][j] = f[f[i][j - 1]][j - 1];
mn[i][j] = min(mn[i][j - 1], mn[f[i][j - 1]][j - 1]);
}
}
int get_lca(int x, int y, ll &M){
M = INF;
if(dep[x] < dep[y]) swap(x, y);
for(int i = 20; i >= 0; --i)
if(dep[f[x][i]] >= dep[y]){
M = min(M, mn[x][i], mn[y][i]);
x = f[x][i];
}
if(x == y) return x;
for(int i = 20; i >= 0; --i)
if(f[x][i] != f[y][i]){
M = min(M, mn[x][i], mn[y][i]);
x = f[x][i], y = f[y][i];
}
M = min(M, min(mn[x][0], mn[y][0]));
return f[x][0];
}
bool vis[maxn]; ll dp[maxn];
void Dfs(int u, int fa){
dp[u] = 0;
for(int i = Head[u]; ~i; i = E[i].next){
int v = E[i].to; ll w = E[i].w; if(v == fa) continue;
Dfs(v, u);
if(vis[v]) dp[u] += w;
else dp[u] += min(w, dp[v]);
}
}
inline bool cmp(int x, int y){return id[x] < id[y];}
int st[maxn], top, a[maxn];
void solve(int m){
sort(a + 1, a + m + 1, cmp);
st[top = 1] = 1; Head[1] = -1; c2 = 0;;
for(int i = 1; i <= m; ++i){ ll t;
int l = get_lca(st[top], a[i], t);
if(l != st[top]){
while(id[l] < id[st[top - 1]]){
ll w; int u = st[top], v = st[top - 1];
get_lca(u, v, w); Add_edge(u, v, w); Add_edge(v, u, w);
--top;
}
if(id[l] > id[st[top - 1]]){
ll w; Head[l] = -1; get_lca(l, st[top], w);
Add_edge(l, st[top], w); Add_edge(st[top], l, w);
st[top] = l;
}
else{
ll w; get_lca(l, st[top], w);
Add_edge(l, st[top], w); Add_edge(st[top], l, w);
--top;
}
}
Head[a[i]] = -1; st[++top] = a[i];
}
for(int i = 1; i < top; ++i){
int u = st[i], v = st[i + 1]; ll w;
get_lca(u, v, w);
Add_edge(u, v, w); Add_edge(v, u, w);
}
Dfs(1, 0); printf("%lld\n", dp[1]);
}
int main(){ memset(head, -1, sizeof head); memset(Head, -1, sizeof Head);
scanf("%d", &n);
for(int i = 0; i <= n; ++i)
for(int j = 0; j <= 20; ++j) mn[i][j] = INF;
for(int i = 1; i < n; ++i){
int x, y, z; scanf("%d%d%d", &x, &y, &z);
add_edge(x, y, z); add_edge(y, x, z);
}
dep[1] = 1; dfs(1, 0); init_lca();
scanf("%d", &m);
for(int i = 1; i <= m; ++i){
int x; scanf("%d", &x);
for(int j = 1; j <= x; ++j) scanf("%d", &a[j]), vis[a[j]] = 1;
solve(x);
for(int j = 1; j <= x; ++j) vis[a[j]] = 0;
}
return 0;
}
T2 洛谷 P4103 [HEOI2014]大工程
题目描述
国家有一个大工程，要给一个非常大的交通网络里建一些新的通道。
我们这个国家位置非常特殊，可以看成是一个单位边权的树，城市位于顶点上。
在 2 个国家 a,b 之间建一条新通道需要的代价为树上 a,b 的最短路径。
现在国家有很多个计划，每个计划都是这样，我们选中了 k 个点，然后在它们两两之间 新建 C(k,2)条 新通道。现在对于每个计划，我们想知道： 1.这些新通道的代价和 2.这些新通道中代价最小的是多少 3.这些新通道中代价最大的是多少
输入输出格式
输入格式：
第一行 n 表示点数。
接下来 n-1 行，每行两个数 a,b 表示 a 和 b 之间有一条边。点从 1 开始标号。
接下来一行 q 表示计划数。对每个计划有 2 行，第一行 k 表示这个计划选中了几个点。
第二行用空格隔开的 k 个互不相同的数表示选了哪 k 个点。
输出格式：
输出 q 行，每行三个数分别表示代价和，最小代价，最大代价。
输入输出样例
输入样例#1：
10
2 1
3 2
4 1
5 2
6 4
7 5
8 6
9 7
10 9
5
2
5 4
2
10 4
2
5 2
2
6 1
2
6 1
输出样例#1：
3 3 3
6 6 6
1 1 1
2 2 2
2 2 2
说明
对于第 1,2 个点: n<=10000
对于第 3,4,5 个点: n<=100000,交通网络构成一条链
对于第 6,7 个点: n<=100000
对于第 8,9,10 个点: n<=1000000
对于所有数据, q<=50000并且保证所有k之和<=2*n
思路：显然虚树。考虑建出虚树后。对于最大和最小，\(f[u]\) 表示 u 的子树中的最短链，\(g[u]\) 表示 u 的子树的中最长链，然后就可以维护，稍微需要特判下关键点和非关键点。对于总代价，只需要按照边来计算，即算每条边下面有多少点，上面有多少点，乘起来就是这条边的贡献。
#include<iostream>
#include<cstdio>
#include<cctype>
#include<algorithm>
#include<cstring>
#define maxn 1000010
#define INF 1000000
#define ll long long
#define gc() getchar()
using namespace std;
int n, m;
int read(){
int x = 0; char c = gc();
while(!isdigit(c)) c = gc();
while(isdigit(c)){x = x * 10 + c - '0'; c = gc();}
return x;
}
struct Edge{
int to, next, w;
}e[maxn * 2], E[maxn * 2]; int c1, head[maxn], c2, Head[maxn];
inline void add_edge(int u, int v, int w){
e[c1].to = v; e[c1].w = w;
e[c1].next = head[u]; head[u] = c1++;
e[c1].to = u; e[c1].w = w;
e[c1].next = head[v]; head[v] = c1++;
}
inline void Add_edge(int u, int v, int w){
E[c2].to = v; E[c2].w = w;
E[c2].next = Head[u]; Head[u] = c2++;
E[c2].to = u; E[c2].w = w;
E[c2].next = Head[v]; Head[v] = c2++;
}
int ou[maxn * 2], in[maxn], id[maxn], c3, dis[maxn], c4;
void Dfs(int u, int fa, int w){
ou[++c3] = u; in[u] = c3; dis[u] = w; id[u] = ++c4;
for(int i = head[u]; ~i; i = e[i].next){
int v = e[i].to; if(v == fa) continue;
Dfs(v, u, w + 1); ou[++c3] = u;
}
}
inline int st_min(int l, int r){
return in[l] < in[r] ? l : r;
}
int Log[maxn * 2], St[maxn * 2][21];
void init_lca(){ Log[0] = -1;
for(int i = 1; i <= c3; ++i) Log[i] = Log[i >> 1] + 1;
for(int i = 1; i <= c3; ++i) St[i][0] = ou[i];
for(int j = 1; j <= 20; ++j)
for(int i = 1; i + (1 << j) - 1 <= c3; ++i)
St[i][j] = st_min(St[i][j - 1], St[i + (1 << j - 1)][j - 1]);
}
inline int get_lca(int l, int r){
l = in[l]; r = in[r]; if(l > r) swap(l, r);
int x = Log[r - l + 1];
return st_min(St[l][x], St[r - (1 << x) + 1][x]);
}
inline int D(int x, int y){
return dis[x] + dis[y] - 2 * dis[get_lca(x, y)];
}
int sz[maxn], f[maxn], g[maxn], N, du[maxn]; ll s; int s1, s2; bool vis[maxn];
void dfs1(int u, int fa){
sz[u] = vis[u];
for(int i = Head[u]; ~i; i = E[i].next){
int v = E[i].to, w = E[i].w; if(v == fa) continue;
dfs1(v, u); sz[u] += sz[v];
}
}
void dfs2(int u, int fa){
f[u] = vis[u] ? 0 : INF; g[u] = vis[u] ? 0 : -INF;
for(int i = Head[u]; ~i; i = E[i].next){
int v = E[i].to, w = E[i].w; if(v == fa) continue;
dfs2(v, u);
s1 = min(s1, f[u] + f[v] + w); s2 = max(s2, g[u] + g[v] + w);
f[u] = min(f[u], f[v] + w); g[u] = max(g[u], g[v] + w);
s += 1ll * w * (N - sz[v]) * sz[v];
}
}
inline bool cmp(int x, int y){return in[x] < in[y];}
int a[maxn], st[maxn], top;
void solve(int m){
sort(a + 1, a + m + 1, cmp);
st[top = 1] = 1; Head[1] = -1; s = 0; c2 = 0; s2 = -INF; s1 = INF;
for(int i = 1; i <= m; ++i){ if(a[i] == 1) continue;
int lca = get_lca(a[i], st[top]);
if(lca != st[top]){
while(id[lca] < id[st[top - 1]]){
Add_edge(st[top], st[top - 1], D(st[top], st[top - 1]));
--top;
}
if(id[lca] > id[st[top - 1]]){
Head[lca] = -1;
Add_edge(lca, st[top], D(lca, st[top]));
st[top] = lca;
}
else{
Add_edge(lca, st[top], D(lca, st[top]));
--top;
}
}
Head[a[i]] = -1; st[++top] = a[i];
}
for(int i = 1; i < top; ++i) Add_edge(st[i], st[i + 1], D(st[i], st[i + 1]));
dfs1(1, 0); N = sz[1]; dfs2(1, 0);
printf("%lld %d %d\n", s, s1, s2);
}
int main(){ memset(head, -1, sizeof head); memset(Head, -1, sizeof Head);
n = read();
for(int i = 1; i < n; ++i){
int x = read(), y = read();
add_edge(x, y, 1);
}
Dfs(1, 0, 0); init_lca();
m = read();
for(int i = 1; i <= m; ++i){
int x = read();
for(int j = 1; j <= x; ++j) vis[a[j] = read()] = 1;
solve(x);
for(int j = 1; j <= x; ++j) vis[a[j]] = 0;
}
return 0;
}
T3 洛谷 P3233 [HNOI2014]世界树
题目描述
世界树是一棵无比巨大的树，它伸出的枝干构成了整个世界。在这里，生存着各种各样的种族和生灵，他们共同信奉着绝对公正公平的女神艾莉森，在他们的信条里，公平是使世界树能够生生不息、持续运转的根本基石。
世界树的形态可以用一个数学模型来描述：世界树中有 nnn 个种族，种族的编号分别从 111 到 nnn ，分别生活在编号为 111 到 nnn 的聚居地上，种族的编号与其聚居地的编号相同。有的聚居地之间有双向的道路相连，道路的长度为 111 。保证连接的方式会形成一棵树结构，即所有的聚居地之间可以互相到达，并且不会出现环。定义两个聚居地之间的距离为连接他们的道路的长度；例如，若聚居地 aaa 和 bbb 之间有道路， bbb 和 ccc 之间有道路，因为每条道路长度为 111 而且又不可能出现环，所以 aaa 与 ccc 之间的距离为 222 。
于对公平的考虑，第 iii 年，世界树的国王需要授权 mim_imi 个种族的聚居地为临时议事处。对于某个种族 xxx （ xxx 为种族的编号），如果距离该种族最近的临时议事处为 yyy （ yyy 为议事处所在聚居地的编号），则种族 xxx 将接受 yyy 议事处的管辖（如果有多个临时议事处到该聚居地的距离一样，则 yyy 为其中编号最小的临时议事处）。
在国王想知道，在 qqq 年的时间里，每一年完成授权后，当年每个临时议事处将会管理多少个种族（议事处所在的聚居地也将接受该议事处管理）。 现在这个任务交给了以智慧著称的灵长类的你：程序猿。请帮国王完成这个任务吧。
输入输出格式
输入格式：
第一行为一个正整数n，表示世界树中种族的个数。接下来n-l行，每行两个正整数x，y，表示x聚居地与y聚居地之间有一条长度为1的双向道路。接下来一行为一个正整数q，表示国王询问的年数。接下来q块，每块两行：第i块的第一行为1个正整数m[i]，表示第i年授权的临时议事处的个数。第i块的第二行为m[i]个正整数h[l]、h[2]、...、h[m[i]]，表示被授权为临时议事处的聚居地编号（保证互不相同）。
输出格式：
输出包含q行，第i行为m[i]个整数，该行的第j(j=1，2...，，m[i])个数表示第i年被授权的聚居地h[j]的临时议事处管理的种族个数。
输入输出样例
输入样例#1：
10
2 1
3 2
4 3
5 4
6 1
7 3
8 3
9 4
10 1
5
2
6 1
5
2 7 3 6 9
1
8
4
8 7 10 3
5
2 9 3 5 8
输出样例#1：
1 9
3 1 4 1 1
10
1 1 3 5
4 1 3 1 1
说明
N<=300000, q<=300000,m[1]+m[2]+...+m[q]<=300000
思路：首先是虚树题。先考虑只有一次询问的情况，发现可以两次 dfs 求出里每个点最近的关键点。第一遍用儿子更新父亲，第二遍用父亲更新儿子。这是一次询问。考虑多次询问，建出虚树。考虑计算答案，对于虚树上的每条边统计答案，即这条边的端点分别能获得多少。考虑如果都是关键点，那么直接二分中间的分界点就好了，如果一个关键点一个非关键点的话，就二分离非关键点最近的关键点和这个关键点的路径，反正关键点一定在这个关键点和非关键点的路径上。嘴巴AC 。代码是看参考别人的。
#include<iostream>
#include<cstdio>
#include<cctype>
#include<cstring>
#include<algorithm>
#define maxn 300010
#define gc() getchar();
using namespace std;
int n, m;
int read(){
int x = 0; char c = gc();
while(!isdigit(c)) c = gc();
while(isdigit(c)){x = x * 10 + c - '0'; c = gc();}
return x;
}
struct Edge{
int to, next;
}e[maxn * 2], E[maxn * 2]; int c1, head[maxn], c2, Head[maxn];
inline void add_edge(int u, int v){
e[c1].to = v; e[c1].next = head[u]; head[u] = c1++;
e[c1].to = u; e[c1].next = head[v]; head[v] = c1++;
}
inline void Add_edge(int u, int v){
E[c2].to = v; E[c2].next = Head[u]; Head[u] = c2++;
E[c2].to = u; E[c2].next = Head[v]; Head[v] = c2++;
}
int sz[maxn], f[maxn][21], dep[maxn], id[maxn], c3;
void dfs(int u, int fa){
sz[u] = 1; id[u] = ++c3;
for(int i = head[u]; ~i; i = e[i].next){
int v = e[i].to; if(v == fa) continue;
dep[v] = dep[u] + 1; f[v][0] = u;
dfs(v, u); sz[u] += sz[v];
}
}
void init_lca(){
for(int j = 1; j <= 20; ++j)
for(int i = 1; i <= n; ++i) f[i][j] = f[f[i][j - 1]][j - 1];
}
int get_lca(int x, int y){
if(dep[x] < dep[y]) swap(x, y);
for(int i = 20; i >= 0; --i)
if(dep[f[x][i]] >= dep[y]) x = f[x][i];
if(x == y) return x;
for(int i = 20; i >= 0; --i)
if(f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
inline int D(int x, int y){
return dep[x] + dep[y] - 2 * dep[get_lca(x, y)];
}
int bl[maxn], g[maxn];
void dfs1(int u, int fa){
g[u] = sz[u];
for(int i = Head[u]; ~i; i = E[i].next){
int v = E[i].to, d1, d2; if(v == fa) continue;
dfs1(v, u); if(!bl[v]) continue;
if(!bl[u]) bl[u] = bl[v];
else{
d1 = D(u, bl[u]); d2 = D(u, bl[v]);
if(d2 < d1 || (d1 == d2 && bl[v] < bl[u])) bl[u] = bl[v];
}
}
}
void dfs2(int u, int fa){
for(int i = Head[u]; ~i; i = E[i].next){
int v = E[i].to, d1, d2; if(v == fa) continue;
if(!bl[v]) bl[v] = bl[u];
else{
d1 = D(v, bl[v]); d2 = D(v, bl[u]);
if(d2 < d1 || (d1 == d2 && bl[u] < bl[v])) bl[v] = bl[u];
}
dfs2(v, u);
}
}
int p[maxn];
void work(int u, int v){
int son = v;
for(int i = 20; i >= 0; --i) if(dep[f[son][i]] > dep[u]) son = f[son][i];
g[u] -= sz[son];
if(bl[u] == bl[v]){p[bl[u]] += sz[son] - sz[v]; return ;}
int ans = v;
for(int i = 20; i >= 0; --i){
int x = f[ans][i]; if(dep[x] <= dep[u]) continue;
int d1 = D(x, bl[u]), d2 = D(x, bl[v]);
if(d1 > d2 || (d1 == d2 && bl[v] < bl[u])) ans = x;
}
p[bl[u]] += sz[son] - sz[ans];
p[bl[v]] += sz[ans] - sz[v];
}
void dfs3(int u, int fa){
for(int i = Head[u]; ~i; i = E[i].next){
int v = E[i].to; if(v == fa) continue;
work(u, v); dfs3(v, u);
}
}
inline bool cmp(int x, int y){return id[x] < id[y];}
int a[maxn], b[maxn], c4, st[maxn], top;
void solve(int m){
for(int i = 1; i <= m; ++i) bl[a[i]] = a[i], b[i] = a[i];
sort(a + 1, a + m + 1, cmp); c4 = m; Head[1] = -1; st[top = 1] = 1; if(a[1] != 1) b[++c4] = 1;
for(int i = 1; i <= m; ++i){ if(a[i] == 1) continue;
int lca = get_lca(a[i], st[top]);
if(lca != st[top]){
while(id[lca] < id[st[top - 1]]){
Add_edge(st[top], st[top - 1]);
--top;
}
if(id[lca] > id[st[top - 1]]){
Head[lca] = -1; b[++c4] = lca;
Add_edge(st[top], lca); st[top] = lca;
}
else Add_edge(st[top], lca), --top;
}
Head[a[i]] = -1; st[++top] = a[i];
}
for(int i = 1; i < top; ++i) Add_edge(st[i], st[i + 1]);
dfs1(1, 0); dfs2(1, 0);
dfs3(1, 0);
for(int i = 1; i <= c4; ++i) p[bl[b[i]]] += g[b[i]];
for(int i = 1; i <= m; ++i) printf("%d ", p[b[i]]); putchar('\n');
for(int i = 1; i <= c4; ++i) bl[b[i]] = p[b[i]] = g[b[i]] = 0;
}
int main(){
memset(head, -1, sizeof head); memset(Head, -1, sizeof Head);
n = read();
for(int i = 1; i < n; ++i){
int x = read(), y = read();
add_edge(x, y);
}
dep[1] = 1; dfs(1, 0); init_lca();
m = read();
for(int i = 1; i <= m; ++i){
int x = read();
for(int j = 1; j <= x; ++j) a[j] = read();
solve(x);
}
return 0;
}
