学习笔记——虚树
模板题引入
先来看一道模板题,CF 上的。
这题的意思是给定一棵有 \(n\) 个节点的树,树上有一些关键点(\(key\))。接下来有 \(q\) 组询问,每次给出 \(k_i\) 个 \(key\),要求删去一些点,使得这些 \(key\) 不相连。要求删去的最少的点数。
模板题解析
第一眼看到这题,先想到的肯定是树形 \(dp\)。毕竟是在树上嘛。但是接下来看了一眼范围 \(1\le n\le 100000\),而且 \(1\le q\le 100000\)。如果对于每个 \(q\) 都跑一次完整的树,那么显然,\(O(n\times q)\) 一算就会 \(TLE\)。
那么我们可以先不考虑这个,先想怎么 \(dp\)。很简单,运用贪心,分类。
如果当前节点是关键点,那么查询它是否有子儿子是关键点,如果有,那么显然连向这个子节点的链上需要被截断,否则就不用。
如果不是关键点,那么如果子树中有关键点并且多于 \(2\) 个,那么显然,把当前节点删掉会最优,如果只有一个,那么留到后面和其他子树中的关键点分割更优。
因此,设当前节点是 \(x\),它的儿子是 \(son\),定义 \(dp[i]\) 表示以 \(i\) 为根的子树,使得所有的 \(key\) 都不连通的最小删点个数,\(siz[i]\) 表示以 \(i\) 为根的子树里 \(key\) 的个数。则有:
\(if(x\;is\;key)\)
\(\qquad dp[x]+=dp[son];\)
\(\qquad\qquad if(siz[son]) ans[x]++;\)
\(else\)
\(\qquad ans[x]+=ans[son];\)
\(\qquad siz[x]+=siz[son];\)
\(\qquad\cdots\)
\(\qquad if(siz[x]>1)\)
\(\qquad\qquad siz[x]=0;\)
\(\qquad\qquad ans[x]++;\)
无解很简单,只有当两个 \(key\) 相连的时候是无解的。
虚树
接下来我们考虑一开始提出的问题。
读题几遍后发现:
因此如果我们只考虑 \(key\),那么是十分快的,只有\(O(k)\)。所以我们随便建了一棵树,并写了几个 \(key\)。
那么显然,结果只和 \(key\) 有关,因此我们可以将其压缩,只保留红色节点即可。
但是马上发现,只留下蓝色和红色的,会发现不够啊,如果只有红色的节点,无法使得节点之间的父子关系显示出来,无法很好地 \(dp\)。因此下面这个绿色的点也需要保留,以表示绿色下面的是其儿子,从而传递。
多写几棵树,就可以发现,其实只要把 \(key\) 和几个 \(key\) 的 \(LCA\) 保留,就可以维护树的形状,又能简化树,使得 \(dp\) 的复杂度大大降低。
此时就变成了删边使得每个 \(key\) 都不相连。(判断无解只要在简化之前做就可以了,这样每个 \(key\) 之间都会有点可以删,就可以变成删边)
像这样建出来的只保留 \(key\) 的树,称之为虚树。
虚树通常是树形 \(dp\) 时常用的优化操作。上面这棵树简化后是这样的:
看,是不是简单了很多呢?
建虚树
首先需要建出实树,然后算出 \(dfs\) 序的编号,然后求 \(LCA\),将 \(LCA\) 也加入到虚树里即可。那么 \(LCA\) 选用倍增的方式求,要求出每个节点的 \(deep\)。当然也可以不用倍增,只要能求出来就好。
建实树,\(fa\) 是倍增用的。(别问怎么又是这个 \(QAQ\))
void QAQ(int x,int f,int depth)
{
ldfn[x]=++cnt;//顺搜的dfn
dep[x]=depth;//深度
fa[x][0]=f;//x节点向上跳2^0步就是它的父节点
for(int i=1;i<20;i++)
fa[x][i]=fa[fa[x][i-1]][i-1];
for(int i=0;i<rea[x].size();i++)//遍历实树
if(rea[x][i]!=f)
QAQ(rea[x][i],x,depth+1);
rdfn[x]=cnt;//回溯的dfn,后文会讲为什么要存回溯的
}
求 \(LCA\),倍增的板子。
int LCA(int x,int y)
{
if(dep[x]<dep[y]) swap(x,y);
int delta=dep[x]-dep[y];
for(int i=0;i<20&δi++)
if(delta&(1<<i))
x=fa[x][i];
if(x==y) return x;
for(int i=19;i>=0;i--)
if(fa[x][i]!=fa[y][i]){
x=fa[x][i];
y=fa[y][i];
}
return fa[x][0];
}//?不会有人还不知道倍增吧,不会吧不会吧。
接下来就是比较困难的建虚树。首先我们要理解其原理。
先把元素按 \(ldfn\) 排序。维护一个树链,对于一个待插入的元素,在当前的树链上找,找到第一个这个元素的祖先,就把这个元素插入到这个祖先的子树里去即可。
原理非常简单,但是怎么实现呢?首先观察一个元素的祖先唯一满足什么条件。不妨对于上面的树,我们算一下 \(ldfn\) 和 \(rdfn\),以数对 \((ldfn,rdfn)\) 的形式列出来,然后找规律。
注意,回溯的时候编号不加一。
我们可以发现,对于一条树链,一个节点 \(a\) 如果是节点 \(b\) 的祖先,那么必定是 \(rdfn[a]\ge ldfn[b]\),反之也成立。原因很简单,因为枚举到当前节点的时候,它的祖先节点的 \(rdfn\) 还没有算,要等到这棵子树遍历完后再赋值,那么肯定是比当前节点大的。[1]
接下来就是怎么维护树链了。只要维护一个从底到顶深度不断增加的单调栈即可。每次将当前元素与栈顶元素比较,如果不满足栈顶元素是当前元素的祖先,那么弹出当前栈顶元素直到满足为止,然后将当前元素压入栈,再维护一条新的链。由于元素已经排序,所以肯定是从左到右建立所有的链。
接下来考虑一个问题,\(LCA\)如果每对元素都求的话,复杂度还是很高。因此我们要考虑简化。探索后发现,只要求相邻两个元素的 \(LCA\),由于是按 \(ldfn\) 排序了的元素,这样的 \(LCA\) 肯定覆盖了所有需要的节点,因此只要扫一遍然后怼出 \(LCA\) 即可。
接下来手动模拟一次,以上面的树为例:
接下来看弹出。
看,是不是一样建出来了!看官可以自行造几组样例,按上面的表述去建一建虚树。
接下来给出代码:
bool cmp(int x,int y)
{
return ldfn[x]<ldfn[y];
}//按dfn排序
void build()
{
sort(d+1,d+1+m,cmp);
int keynum=m;
for(int i=1;i<keynum;i++)
d[++m]=LCA(d[i],d[i+1]);//求相邻两个的LCA
sort(d+1,d+1+m,cmp);
m=unique(d+1,d+1+m)-d-1;
//去重,unique对一个已经排序的数组可以实现去重,
//多出来的扔到了数组的后面,并返回数组大小的地址
int top=0;
stk[++top]=d[1];
for(int i=2;i<=m;i++){
while(top&&rdfn[stk[top]]<ldfn[d[i]])
top--;//如果不是祖先,则弹出元素
if(top) vir[stk[top]].push_back(d[i]);//加入到其祖先的子树里
stk[++top]=d[i];//维护新的链
}
}
这样,我们就可以很好地解决复杂度过大的问题了。
给出模板题的标程:带注释
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int MAXN=1e5+100;
int cnt,m;
int ldfn[MAXN],rdfn[MAXN],fa[MAXN][20],dep[MAXN],stk[MAXN],d[MAXN],vis[MAXN];
vector<int> rea[MAXN],vir[MAXN];
int ans[MAXN],siz[MAXN];
void QAQ(int x,int f,int depth)
{
ldfn[x]=++cnt;
dep[x]=depth;
fa[x][0]=f;
for(int i=1;i<20;i++)
fa[x][i]=fa[fa[x][i-1]][i-1];
for(int i=0;i<rea[x].size();i++)
if(rea[x][i]!=f)
QAQ(rea[x][i],x,depth+1);
rdfn[x]=cnt;
}
int LCA(int x,int y)
{
if(dep[x]<dep[y]) swap(x,y);
int delta=dep[x]-dep[y];
for(int i=0;i<20&δi++)
if(delta&(1<<i))
x=fa[x][i];
if(x==y) return x;
for(int i=19;i>=0;i--)
if(fa[x][i]!=fa[y][i]){
x=fa[x][i];
y=fa[y][i];
}
return fa[x][0];
}
bool cmp(int x,int y)
{
return ldfn[x]<ldfn[y];
}
void build()
{
sort(d+1,d+1+m,cmp);
int keynum=m;
for(int i=1;i<keynum;i++)
d[++m]=LCA(d[i],d[i+1]);
sort(d+1,d+1+m,cmp);
m=unique(d+1,d+1+m)-d-1;
int top=0;
stk[++top]=d[1];
for(int i=2;i<=m;i++){
while(top&&rdfn[stk[top]]<ldfn[d[i]])
top--;
if(top) vir[stk[top]].push_back(d[i]);
stk[++top]=d[i];
}
}
void dfs(int x)
{
ans[x]=0;
if(vis[x]){
siz[x]=1;
for(int i=0;i<vir[x].size();i++){
int son=vir[x][i];
dfs(son);
ans[x]+=ans[son];
if(siz[son]) ans[x]++;
}
}
else{
siz[x]=0;
for(int i=0;i<vir[x].size();i++){
int son=vir[x][i];
dfs(son);
ans[x]+=ans[son];
siz[x]+=siz[son];
}
if(siz[x]>1){
siz[x]=0;
ans[x]++;
}
}
}
int main()
{
int n,q,u,v;
while(~scanf("%d",&n)){
for(int i=0;i<=n;i++)
rea[i].clear();
for(int i=1;i<n;i++){
scanf("%d%d",&u,&v);
rea[u].push_back(v);
rea[v].push_back(u);
}
cnt=0;
QAQ(1,0,0);
scanf("%d",&q);
while(q--){
scanf("%d",&m);
for(int i=1;i<=m;i++){
scanf("%d",&d[i]);
vis[d[i]]=1;
}
int fl=1;
for(int i=1;i<=m;i++)
if(vis[fa[d[i]][0]]){
fl=0;break;
}
if(!fl) puts("-1");
else{
build();dfs(d[1]);
printf("%d\n",ans[d[1]]);
}
for(int i=1;i<=m;i++)
vis[d[i]]=0,vir[d[i]].clear();
}
}
}
例题一枚
非常经典的,虚树必刷的消耗战,洛谷上的链接。
其实就是上面题的简化版,要求所有的 \(key\) 都不与 \(1\) 连通。同样的先摆好 \(dp\),再想建虚树。直接看代码注释吧。
#include<bits/stdc++.h>
#define ll long long
#define inf 1ll<<60
using namespace std;
const int MAXN=250010;
struct node{
ll to,w;
node(){}
node(ll _to,ll _w){
to=_to,w=_w;
}
};//注意实树里要存边权值
ll m,cnt,ldfn[MAXN],rdfn[MAXN],dep[MAXN],fa[MAXN][20],d[MAXN<<1];
ll stk[MAXN],dp[MAXN],w[MAXN];
//dp[i]表示i的子树割断的最小花费
bool vis[MAXN];
vector<node> rea[MAXN];
vector<ll> vir[MAXN];
void QAQ(ll x,ll f,ll depth)
{
ldfn[x]=++cnt;
dep[x]=depth;
fa[x][0]=f;
for(ll i=1;i<20;i++)
fa[x][i]=fa[fa[x][i-1]][i-1];
for(ll i=0;i<rea[x].size();i++)
if(rea[x][i].to!=f){
w[rea[x][i].to]=min(w[x],rea[x][i].w);
//由于只要隔断1,因此维护每个节点到1的最短边割断即可
QAQ(rea[x][i].to,x,depth+1);
}
rdfn[x]=cnt;
}
ll LCA(ll x,ll y)
{
if(dep[x]<dep[y]) swap(x,y);
ll delta=dep[x]-dep[y];
for(ll i=0;i<20&δi++)
if(delta&(1<<i))
x=fa[x][i];
if(x==y) return x;
for(ll i=19;i>=0;i--)
if(fa[x][i]!=fa[y][i]){
x=fa[x][i];
y=fa[y][i];
}
return fa[x][0];
}
bool cmp(ll x,ll y){return ldfn[x]<ldfn[y];}
void build()
{
sort(d+1,d+1+m,cmp);
ll keynum=m;
for(ll i=1;i<keynum;i++)
d[++m]=LCA(d[i],d[i+1]);
d[++m]=1;
sort(d+1,d+1+m,cmp);
m=unique(d+1,d+1+m)-d-1;
ll top=0;
stk[++top]=d[1];
for(ll i=2;i<=m;i++){
while(top&&rdfn[stk[top]]<ldfn[d[i]])
top--;
if(top) vir[d[i]].push_back(stk[top]),
vir[stk[top]].push_back(d[i]);
stk[++top]=d[i];
}
}//板子
void dfs(ll x,ll fa)
{
if(vir[x].size()<=0&&vis[x]){
dp[x]=inf;//叶节点并且不是key,则不用考虑,因此为inf
return;
}
for(ll i=0;i<vir[x].size();i++){
ll son=vir[x][i];
if(son==fa) continue;
dfs(son,x);
if(vis[son]) dp[x]+=w[son];//如果儿子是key,那么显然要把这个儿子割断
else dp[x]+=min(w[son],dp[son]);//否则可以考虑割断儿子的其他子树会更小
}
}
int main()
{
ll n,u,v,t,q;
scanf("%lld",&n);
for(ll i=1;i<n;i++){
scanf("%lld%lld%lld",&u,&v,&t);
rea[u].push_back(node(v,t));
rea[v].push_back(node(u,t));
}
cnt=0;w[1]=inf;
QAQ(1,0,0);
// for(int i=1;i<=n;i++) cerr<<w[i]<<' ';
scanf("%lld",&q);
while(q--){
scanf("%lld",&m);
for(ll i=1;i<=m;i++) scanf("%lld",&d[i]),vis[d[i]]=1;
build();
dfs(d[1],-1);
printf("%lld\n",dp[1]);
for(ll i=1;i<=m;i++) dp[d[i]]=0,vis[d[i]]=0,vir[d[i]].clear();
//精准扶贫,防TLE
}
}
其实消耗战才是模板题,只是因为它有关权值,所以把它放到应用。
总结
虚树和矩阵快速幂一样,是优化型的算法。使用虚树的条件:
- 有关键点,且关键点的数量少。
- 有必要。显然,如果裸的 \(dp\) 可以跑,为什么要敲个虚树的板子呢?
以此记录虚树的学习。
这里可以回答上面注释里的问题了,由于只维护 \(ldfn\) 会产生混淆,比如上面的 \((8,8)\) 就会放到 \((7,7)\) 的下面而不是 \((6,8)\) 的儿子。 ↩︎