ACM--虚树

虚树其实就是只对关键点信息的维护，不需要修改部分点之后又跑完整棵树
板题

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=1e6+10;
typedef pair<int,int>PII;
typedef vector<int>vi;
int n,m,u,v,w,a[N],f[N],o,in[N],out[N],dep[N],vis[N];
int fa[N][21];
vector<PII>g[N],vg[N];
void dfs(int u,int F=0){
    
    
    in[u]=++o;
    dep[u]=dep[F]+1;
    fa[u][0]=F;
    for(int k=1;k<=20;k++)fa[u][k]=fa[fa[u][k-1]][k-1];
    for(auto [j,w]:g[u]){
    
    
        if(j==F)continue;
        a[j]=min(a[u],w);
        dfs(j,u);
    }
    out[u]=o;
}
void vdfs(int u){
    
    
    f[u]=0;
    for(auto [j,w]:vg[u]){
    
    
        vdfs(j);
        if(vis[j])f[u]+=w;
        else f[u]+=min(f[j],w);
    }
}
bool cmp(int u,int v){
    
    
    return in[u]<in[v];
}
int isp(int u,int v){
    
    
    return in[u]<=in[v]&&out[v]<=out[u];
}
int lca(int a,int b){
    
    
    if(dep[a]<dep[b])swap(a,b);
    for(int k=20;k>=0;k--)if(dep[fa[a][k]]>=dep[b])a=fa[a][k];
    if(a==b)return a;
    for(int k=20;k>=0;k--){
    
    
        if(fa[a][k]!=fa[b][k])a=fa[a][k],b=fa[b][k];
    }
    return fa[a][0];
}
void build(vi &node){
    
    
    sort(node.begin(),node.end(),cmp);
    set<int>S;
    for(auto x:node)S.insert(x);
    for(int i=1;i<node.size();i++)S.insert(lca(node[i-1],node[i]));
    node.clear();
    for(auto x:S)node.push_back(x);
    sort(node.begin(),node.end(),cmp);
    vi v;
    for(auto x:node){
    
    
        while(!v.empty()&&!isp(v.back(),x))v.pop_back();
        if(!v.empty())vg[v.back()].push_back({
    
    x,a[x]});
        v.push_back(x);
    }
}
signed main(){
    
    
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    cin>>n;
    for(int i=1;i<n;i++){
    
    
        cin>>u>>v>>w;
        g[u].push_back({
    
    v,w});
        g[v].push_back({
    
    u,w});
    }
    memset(a,0x3f,sizeof a);
    dfs(1);
    cin>>m;
    while(m--){
    
    
        int k;
        cin>>k;
        vi node;
        for(int i=0;i<k;i++){
    
    
            int x;
            cin>>x;
            node.push_back(x);
            vis[x]=1;
        }
        node.push_back(1);
        build(node);
        //virtual dfs
        //虚树其实就是只对关键点信息的维护，不需要修改部分点之后又跑完整棵树
        vdfs(1);
        cout<<f[1]<<'\n';
        for(auto x:node)vg[x].clear(),vis[x]=0;
        //虚树每次跑完都要清空
    }
}

---

杭电多校第二场A

虚树压缩树，AB往上打标记，C往下打标记
考虑这样一种答案

ab会相遇在j点，然后终止于u点
为了防止重复计算，对ans贡献为u和j距离减1，即ans+=dist(u,j)-1
对于某节点，如果它同时有三种标记，那么它会重复出现在多次贡献中，所以只需要最后ans+1就好
这道题提醒我们对于虚树的答案计数方法

#include<bits/stdc++.h>
// #define int long long
using namespace std;
const int N=2e5+10;
typedef pair<int,int>PII;
typedef vector<int>vi;
int n,m,u,v,w,a[N],f[N],o,in[N],out[N],dep[N],vis[N];
int fa[N][21];
int ab[N],c[N];
int ans=0;
vector<int>g[N],vg[N];
void dfs(int u,int F=0){
    
    
    in[u]=++o;
    dep[u]=dep[F]+1;
    fa[u][0]=F;
    for(int k=1;k<=20;k++)fa[u][k]=fa[fa[u][k-1]][k-1];
    for(auto j:g[u])dfs(j,u);
    out[u]=o;
}
bool cmp(int u,int v){
    
    
    return in[u]<in[v];
}
int isp(int u,int v){
    
    
    return in[u]<=in[v]&&out[v]<=out[u];
}
int lca(int a,int b){
    
    
    if(dep[a]<dep[b])swap(a,b);
    for(int k=20;k>=0;k--)if(dep[fa[a][k]]>=dep[b])a=fa[a][k];
    if(a==b)return a;
    for(int k=20;k>=0;k--){
    
    
        if(fa[a][k]!=fa[b][k])a=fa[a][k],b=fa[b][k];
    }
    return fa[a][0];
}
void build(vi &node){
    
    
    sort(node.begin(),node.end(),cmp);
    set<int>S;
    for(auto x:node)S.insert(x);
    for(int i=1;i<node.size();i++)S.insert(lca(node[i-1],node[i]));
    node.clear();
    for(auto x:S)node.push_back(x);
    sort(node.begin(),node.end(),cmp);
    vi v;
    for(auto x:node){
    
    
        while(!v.empty()&&!isp(v.back(),x))v.pop_back();
        if(!v.empty())vg[v.back()].push_back(x);
        v.push_back(x);
    }
}
int d(int u,int v){
    
    
    int fa=lca(u,v);
    return dep[u]+dep[v]-2*dep[fa];
}
void vdfs(int u){
    
    //对所有的颜色由下至上
    for(auto j:vg[u]){
    
    
        c[j]|=c[u];
        vdfs(j);
        ab[u]|=ab[j];
        //如果儿子满足条件，那么我也是满足条件的
        if(ab[j]==3&&c[u]==4)ans+=d(u,j)-1;
    }
    if(c[u]==4&&ab[u]==3)ans++;
}
signed main(){
    
    
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int T;
    cin>>T;
    while(T--){
    
    
    cin>>n>>m;
    for(int i=1;i<=n;i++)g[i].clear();
    for(int i=2;i<=n;i++){
    
    
        int fa;
        cin>>fa;
        g[fa].push_back(i);
    }
    dfs(1);
    while(m--){
    
    
        int A,B,C,x;
        cin>>A>>B>>C;
        vi node;
        for(int i=1;i<=A;i++){
    
    
            cin>>x;
            node.push_back(x);
            ab[x]|=1;
        }
        for(int i=1;i<=B;i++){
    
    
            cin>>x;
            node.push_back(x);
            ab[x]|=2;
        }
        for(int i=1;i<=C;i++){
    
    
            cin>>x;
            node.push_back(x);
            c[x]|=4;
        }
        node.push_back(1);
        build(node);
        ans=0;
        vdfs(1);
        cout<<ans<<'\n';
        for(auto x:node)vg[x].clear(),vis[x]=0,ab[x]=0,c[x]=0;
    }
    }
}

---

消耗战

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=1e6+10;
typedef pair<int,int>PII;
typedef vector<int>vi;
int n,m,u,v,w,a[N],f[N],o,in[N],out[N],dep[N],vis[N];
int fa[N][21];
vector<PII>g[N],vg[N];
void dfs(int u,int F=0){
    
    
    in[u]=++o;
    dep[u]=dep[F]+1;
    fa[u][0]=F;
    for(int k=1;k<=20;k++)fa[u][k]=fa[fa[u][k-1]][k-1];
    for(auto [j,w]:g[u]){
    
    
        if(j==F)continue;
        a[j]=min(a[u],w);
        dfs(j,u);
    }
    out[u]=o;
}
void vdfs(int u){
    
    
    f[u]=0;
    for(auto [j,w]:vg[u]){
    
    
        vdfs(j);
        if(vis[j])f[u]+=w;
        else f[u]+=min(f[j],w);
    }
}
bool cmp(int u,int v){
    
    
    return in[u]<in[v];
}
int isp(int u,int v){
    
    
    return in[u]<=in[v]&&out[v]<=out[u];
}
int lca(int a,int b){
    
    
    if(dep[a]<dep[b])swap(a,b);
    for(int k=20;k>=0;k--)if(dep[fa[a][k]]>=dep[b])a=fa[a][k];
    if(a==b)return a;
    for(int k=20;k>=0;k--){
    
    
        if(fa[a][k]!=fa[b][k])a=fa[a][k],b=fa[b][k];
    }
    return fa[a][0];
}
void build(vi &node){
    
    
    sort(node.begin(),node.end(),cmp);
    set<int>S;
    for(auto x:node)S.insert(x);
    for(int i=1;i<node.size();i++)S.insert(lca(node[i-1],node[i]));
    node.clear();
    for(auto x:S)node.push_back(x);
    sort(node.begin(),node.end(),cmp);
    vi v;
    for(auto x:node){
    
    
        while(!v.empty()&&!isp(v.back(),x))v.pop_back();
        if(!v.empty())vg[v.back()].push_back({
    
    x,a[x]});
        v.push_back(x);
    }
}
signed main(){
    
    
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    cin>>n;
    for(int i=1;i<n;i++){
    
    
        cin>>u>>v>>w;
        g[u].push_back({
    
    v,w});
        g[v].push_back({
    
    u,w});
    }
    memset(a,0x3f,sizeof a);
    dfs(1);
    cin>>m;
    while(m--){
    
    
        int k;
        cin>>k;
        vi node;
        for(int i=0;i<k;i++){
    
    
            int x;
            cin>>x;
            node.push_back(x);
            vis[x]=1;
        }
        node.push_back(1);
        build(node);
        //virtual dfs
        //虚树其实就是只对关键点信息的维护，不需要修改部分点之后又跑完整棵树
        vdfs(1);
        cout<<f[1]<<'\n';
        for(auto x:node)vg[x].clear(),vis[x]=0;
        //虚树每次跑完都要清空
    }
}

---

齐鲁工业大学压轴题F

每次询问给k个点，求一个点到这k个点的距离和最小
其实也就是求树的重心
有一个易错点就是，这个点一定是在关键点或者关键点的lca上

//选出一个点使其到达别的点的距离和最小
//其实就是求重心
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=1e5+10;
typedef pair<int,int>PII;
typedef vector<int>vi;
int n,m,u,v,w,a[N],f[N],o,in[N],out[N],dep[N],vis[N],dp[N];
int sz[N],ans,k;
int fa[N][21];
vector<PII>g[N],vg[N];
int cnt[N];
void dfs(int u,int F=0){
    
    
    in[u]=++o;
    dep[u]=dep[F]+1;
    fa[u][0]=F;
    for(int k=1;k<=20;k++)fa[u][k]=fa[fa[u][k-1]][k-1];
    for(auto [j,w]:g[u]){
    
    
        if(j==F)continue;
        a[j]=min(a[u],w);
        dfs(j,u);
    }
    out[u]=o;
}
// void vdfs(int u){
    
    
//     f[u]=0;
//     for(auto [j,w]:vg[u]){
    
    
//         vdfs(j);
//         if(vis[j])f[u]+=w;
//         else f[u]+=min(f[j],w);
//     }
// }
void vdfs(int u,int F=0){
    
    
    f[u]=0;sz[u]=0;
    if(vis[u])sz[u]+=cnt[u];
    for(auto [j,w]:vg[u]){
    
    
        if(j==F)continue;
        vdfs(j,u);
        sz[u]+=sz[j];
        f[u]+=f[j]+(dep[j]-dep[u])*sz[j];
    }
}
void vdfs2(int u,int F=0){
    
    
    if(F)dp[u]=dp[F]+(k-2*sz[u])*(dep[u]-dep[F]);
//     if(F)dp[u]=f[u]+dep[u]-dep[F]+dp[F]-f[u];
//     if(F){
    
    
//         if(sz[u]==sz[F])dp[u]=dp[F]-(dep[u]-dep[F]);
//         else dp[u]=dp[F];
//     }
//     dp[u]=f[u];
//     if(vis[u])ans=min(ans,dp[u]);
    ans=min(ans,dp[u]);
    for(auto [j,w]:vg[u]){
    
    
        if(j==F)continue;
        vdfs2(j,u);
    }
}
bool cmp(int u,int v){
    
    
    return in[u]<in[v];
}
int isp(int u,int v){
    
    
    return in[u]<=in[v]&&out[v]<=out[u];
}
int lca(int a,int b){
    
    
    if(dep[a]<dep[b])swap(a,b);
    for(int k=20;k>=0;k--)if(dep[fa[a][k]]>=dep[b])a=fa[a][k];
    if(a==b)return a;
    for(int k=20;k>=0;k--){
    
    
        if(fa[a][k]!=fa[b][k])a=fa[a][k],b=fa[b][k];
    }
    return fa[a][0];
}
void build(vi &node){
    
    
    sort(node.begin(),node.end(),cmp);
    set<int>S;
    for(auto x:node)S.insert(x);
    for(int i=1;i<node.size();i++)S.insert(lca(node[i-1],node[i]));
    node.clear();
    for(auto x:S)node.push_back(x);
    sort(node.begin(),node.end(),cmp);
    vi v;
    for(auto x:node){
    
    
        while(!v.empty()&&!isp(v.back(),x))v.pop_back();
        if(!v.empty())vg[v.back()].push_back({
    
    x,a[x]});
        v.push_back(x);
    }
}
signed main(){
    
    
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    cin>>n>>m;
    for(int i=1;i<n;i++){
    
    
        cin>>u>>v;
        g[u].push_back({
    
    v,1});
        g[v].push_back({
    
    u,1});
    }
    memset(a,0x3f,sizeof a);
    dfs(1);
    while(m--){
    
    
        int t,x;
        cin>>t>>k;
        vi node;
        for(int i=0;i<k;i++){
    
    
            cin>>x;
            node.push_back(x);
            vis[x]=1;
            cnt[x]++;
        }
        node.push_back(1);
        build(node);
        //virtual dfs
        //虚树其实就是只对关键点信息的维护，不需要修改部分点之后又跑完整棵树
        vdfs(1);
        dp[1]=f[1];
        ans=1e18;
        vdfs2(1);
//         cout<<"f["<<1<<"]="<<f[1]<<'\n';
//         cout<<"dp["<<1<<"]="<<dp[1]<<'\n';
        if(ans<t)cout<<ans<<'\n';
        if(ans>=t) cout<<"Good game"<<'\n';
        for(auto x:node)vg[x].clear(),vis[x]=0,cnt[x]=0;
        //虚树每次跑完都要清空
    }
}

---

P4103 [HEOI2014] 大工程

#include<bits/stdc++.h>
// #define int long long
using namespace std;
const int N=1e6+10;
typedef pair<int,int>PII;
typedef vector<int>vi;
int n,m,u,v,w,a[N],f[N],g[N],o,in[N],out[N],dep[N],vis[N],sz[N];
int fa[N][21];
long long ans1;
int ans2,ans3,k;
vector<PII>G[N],vg[N];
void dfs(int u,int F=0){
    
    
    in[u]=++o;
    dep[u]=dep[F]+1;
    fa[u][0]=F;
    for(int k=1;k<=20;k++)fa[u][k]=fa[fa[u][k-1]][k-1];
    for(auto [j,w]:G[u]){
    
    
        if(j==F)continue;
        a[j]=min(a[u],w);
        dfs(j,u);
    }
    out[u]=o;
}
inline void vdfs(int u,int F=0){
    
    
    if(vis[u])sz[u]=1;
    else sz[u]=0;
    if(vis[u])g[u]=0;
    else g[u]=1e9;
    f[u]=0;
    for(auto [j,w]:vg[u]){
    
    
        if(j==F)continue;
        vdfs(j,u);
    }
    for(auto [j,w]:vg[u]){
    
    
        if(j==F)continue;
        w=dep[j]-dep[u];
        ans1+=1ll*(k-sz[j])*sz[j]*(dep[j]-dep[u]);
        if(sz[u]){
    
    
            ans2=min(ans2,g[u]+g[j]+dep[j]-dep[u]);
            ans3=max(ans3,f[u]+f[j]+dep[j]-dep[u]);
        }
        g[u]=min(g[u],g[j]+dep[j]-dep[u]);
        f[u]=max(f[u],f[j]+dep[j]-dep[u]);
        sz[u]+=sz[j];
    }
}
bool cmp(int u,int v){
    
    
    return in[u]<in[v];
}
int isp(int u,int v){
    
    
    return in[u]<=in[v]&&out[v]<=out[u];
}
inline int lca(int a,int b){
    
    
    if(dep[a]<dep[b])swap(a,b);
    for(int k=20;k>=0;k--)if(dep[fa[a][k]]>=dep[b])a=fa[a][k];
    if(a==b)return a;
    for(int k=20;k>=0;k--){
    
    
        if(fa[a][k]!=fa[b][k])a=fa[a][k],b=fa[b][k];
    }
    return fa[a][0];
}
int cal(int x,int y){
    
    
    return dep[x]+dep[y]-2*dep[lca(x,y)];
}

inline void build(vi &node){
    
    
    sort(node.begin(),node.end(),cmp);
    set<int>S;
    for(auto x:node)S.insert(x);
    for(int i=1;i<node.size();i++)S.insert(lca(node[i-1],node[i]));
    node.clear();
    for(auto x:S)node.push_back(x);
    sort(node.begin(),node.end(),cmp);
    vi v;
    for(auto x:node){
    
    
        while(!v.empty()&&!isp(v.back(),x))v.pop_back();
        if(!v.empty())vg[v.back()].push_back({
    
    x,a[x]});
        v.push_back(x);
    }
}
signed main(){
    
    
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    cin>>n;
    for(int i=1;i<n;i++){
    
    
        cin>>u>>v;
        G[u].push_back({
    
    v,1});
        G[v].push_back({
    
    u,1});
    }
    // memset(a,0x3f,sizeof a);
    dfs(1);
    cin>>m;
    while(m--){
    
    
        cin>>k;
        vi node;
        for(int i=0;i<k;i++){
    
    
            int x;
            cin>>x;
            node.push_back(x);
            vis[x]=1;
        }
        node.push_back(1);
        build(node);
        //virtual dfs
        //虚树其实就是只对关键点信息的维护，不需要修改部分点之后又跑完整棵树
        ans1=0;
        ans2=1e9;
        ans3=0;
        vdfs(1);
        cout<<ans1<<" "<<ans2<<" "<<ans3<<'\n';
        for(auto x:node)vg[x].clear(),vis[x]=0;
        //虚树每次跑完都要清空
    }
}

---