2024牛客暑期多校训练营10 J. Doremy‘s Starch Trees（预处理 换根dp/树上差分）

题目

每次给定n(n<=1e6)个点的两棵树T1和T2，

其中T1是无根树，T2是有根树，但还未确定根，

称有根树T2是无根树T1的starch tree，当且仅当：

1. T1和T2点数相同

2. 对于T2树上每个非叶节点x，对于x的每个儿子y，都至少存在一个z，满足在T1树上，z和x有连边

找到T2的一个根满足T2是T1的starch tree，有多个输出任意一个即可，无解输出-1

实际为t(t<=1e5)组样例，保证sumn不超过1e6

思路来源

乱搞ac

题解

第一个条件显然已经满足，

对于第二个条件，

T2有根树上，对于每个x的直连儿子y，都至少存在一个z，z在T2的y的子树里，

满足在T1无根树上，z是连着x的

考虑预处理有根树T2上每条有向边是否合法，

但是现求很困难，然而所有的相邻边在无根树T1上只有n-1条

所以将其转化为预处理T1上每个(x,z)边的贡献，一旦无根树T1上(x,z)是相连的，

那么有根树T2有向边y->x（y是有根树T2上z->x路径上x相邻的点）就是合法的，

对这条有向边标记一下，预处理所有边的贡献，然后换根dp即可

当然注意到每条边的贡献是独立的，

所以可以直接把边对于哪些点为根时有贡献加上，

直接子树加贡献，那么树上差分即可

这里用的树上差分，树边可以由远端点唯一下标确定，

再开一维2表示这条有向边是远端->近端还是近端->远端

这个在求lca的时候，是知道哪个点是远端的

6s的题，但由于几次dfs，导致常数巨大，

实际O(nlogn)的做法也跑了5s多，优化成找到一个答案就返回，也跑了4s

代码

//#include <bits/stdc++.h>
#include<iostream>
#include<vector>
using namespace std;
#define rep(i,a,b) for(int i=(a);i<=(b);++i)
#define per(i,a,b) for(int i=(a);i>=(b);--i)
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef pair<int,int> P;
#define fi first
#define se second
#define pb push_back
#define dbg(x) cerr<<(#x)<<":"<<x<<" ";
#define dbg2(x) cerr<<(#x)<<":"<<x<<endl;
#define SZ(a) (int)(a.size())
#define sci(a) scanf("%d",&(a))
#define pt(a) printf("%d",a);
#define pte(a) printf("%d\n",a)
#define ptlle(a) printf("%lld\n",a)
#define debug(...) fprintf(stderr, __VA_ARGS__)
using namespace std;
const int N=1e6+10,M=21;
int t,n,u,v,dep[N],st[N][M],add[N],ans;
bool can[N][2];//can[u][0]表示u->fu [1]表示fu->u
P edge[N];
vector<int>e[N],f[N];
void dfs(int u,int fa){//有根树
    dep[u]=dep[fa]+1;
    st[u][0]=fa;
    for(int i=1;i<20;i++){
        st[u][i]=st[st[u][i-1]][i-1];
    }
    for(auto &v:f[u]){
        if(v==fa)continue;
        dfs(v,u);
    }
}
P lca(int u,int v){//返回lca和到lca还差一步的点
    if(dep[u]<dep[v])swap(u,v);
    int x=u;
    for(int i=19;~i;i--){
        if(dep[st[u][i]]>=dep[v])u=st[u][i];
        if(dep[st[x][i]]>dep[v])x=st[x][i];
    }
    if(u==v)return P(u,x);
    for(int i=19;~i;i--){
        if(st[u][i]==st[v][i])continue;
        u=st[u][i],v=st[v][i];
    }
    return P(st[u][0],u);
}
void cal(int u,int v){
    P z=lca(u,v);
    int lc=z.fi,x=z.se,fu=st[u][0],fv=st[v][0];
    if(lc==v){
        if(!can[x][1])can[x][1]=1,add[1]++,add[x]--;
        if(!can[u][0])can[u][0]=1,add[u]++;
    }
    else if(lc==u){
        if(!can[x][1])can[x][1]=1,add[1]++,add[x]--;
        if(!can[v][0])can[v][0]=1,add[v]++;
    }
    else{
        if(!can[v][0])can[v][0]=1,add[v]++;
        if(!can[u][0])can[u][0]=1,add[u]++;
    }
}
int dfs2(int u,int fa){//有根树
    add[u]+=add[fa];
    if(add[u]==n-1)return u;
    for(auto &v:f[u]){
        if(v==fa)continue;
        int ans=dfs2(v,u);
        if(~ans)return ans;
    }
    return -1;
}
void init(){
    rep(i,1,n){
        e[i].clear();
        f[i].clear();
        can[i][0]=can[i][1]=0;
        add[i]=0;
    }
}
int sol(){
    init();
    sci(n);
    rep(i,2,n){
        sci(u);
        edge[i]=P(u,i);
    }
    rep(i,2,n){
        sci(u);
        f[u].pb(i);
        f[i].pb(u);
    }
    dfs(1,0);
    rep(i,2,n)cal(edge[i].fi,edge[i].se);
    return dfs2(1,0);
}

int main(){
    sci(t);
    while(t--){
        pte(sol());
    }
    return 0;
}
/*
T2有根树上，对于每个x的直连儿子y，都至少有一个z，z在y的子树里，在T1无根树上，z连着x
考虑预处理有根树上每条有向边是否合法，
转化为预处理每个(x,z)的贡献，一旦无根树上(x,z)是相连的，
那么T2有向边y->x（y是z->x路径上x相邻的点）就是合法的，打个有向标记
预处理所有贡献，然后换根dp即可
当然注意到每条边的贡献是独立的，所以可以直接子树加贡献，那么树上差分即可
*/