Codeforces 1182 D Complete Mirror —— 树哈希

This way

题意：

给你一棵树，你要找到一个点使得如果以这个点为根，剩下的节点如果深度相同，那么他们所连的边数相同。

题解：

也就是找到一个点使得剩下所有相同深度的子树同构。
那么这棵树要么是这样的：

要么是这样的：

并且重心一定在这个单链上。那么我们只需要找到重心，然后看是否有一条单链，但是这个单链不是随便找的，因为同构的子树也可能是一条单链，所以我们要找那个子树的大小与其它子树不同的那个子树。如果没有，那么要么重心就是根，要么单链的大小与其它子树的大小相同，对于后一种情况，只需要随便找到一条单链即可。

#include<bits/stdc++.h>
using namespace std;
#define ull unsigned long long
#define pa pair<int,int>
const int N=1e5+5;
struct node{
    int to,next;
}e[N*2];
int cnt,head[N],siz[N];
void add(int x,int y){
    e[cnt].to=y;
    e[cnt].next=head[x];
    head[x]=cnt++;
}
int rt;
void dfs(int x,int fa){
    siz[x]=1;
    for(int i=head[x];~i;i=e[i].next){
        int ne=e[i].to;
        if(ne==fa)continue;
        dfs(ne,x);
        siz[x]+=siz[ne];
    }
}
int n;
int f_rt(int x,int fa){
    for(int i=head[x];~i;i=e[i].next){
        int ne=e[i].to;
        if(ne==fa)continue;
        if(siz[ne]>n/2)
            return f_rt(ne,x);
    }
    return x;
}
int h,vis[N];
int con[N],f;
int f_head(int x,int fa){
    if(con[x]>2)
        return 0;
    for(int i=head[x];~i;i=e[i].next){
        int ne=e[i].to;
        if(ne==fa)continue;
        return f_head(ne,x);
    }
    return x;
}
int f_line(int x,int fa){
    vis[x]=1;
    if(x==rt)
        return 1;
    if(con[x]>2)
        return 0;
    for(int i=head[x];~i;i=e[i].next){
        int ne=e[i].to;
        if(ne==fa||vis[ne])continue;
        if(f_line(ne,x))
            return 1;
    }
    return 0;
}
ull f_hash(int x,int fa){
    vector<ull>v;
    for(int i=head[x];~i;i=e[i].next){
        int ne=e[i].to;
        if(ne==fa)continue;
        v.push_back(f_hash(ne,x));
    }
    sort(v.begin(),v.end());
    for(int i=1;i<v.size();i++)
        if(v[i]!=v[i-1])
            f=1;
    ull h=28;
    for(auto i:v)
        h=h*131ll+i;
    return h;
}
int main()
{
    memset(head,-1,sizeof(head));
    scanf("%d",&n);
    if(n==1)
        return 0*printf("1\n");
    int x,y;
    for(int i=1;i<n;i++)
        scanf("%d%d",&x,&y),add(x,y),add(y,x),con[x]++,con[y]++;
    dfs(1,0);
    rt=f_rt(1,0);
    
    
    vector<pa>vec;
    for(int i=head[rt];~i;i=e[i].next){
        int ne=e[i].to;
        if(siz[ne]>siz[rt])
            vec.push_back({n-siz[rt],ne});
        else
            vec.push_back({siz[ne],ne});
    }
    sort(vec.begin(),vec.end());
    if(vec.size()>=3){
        if(vec[0].first!=vec[1].first)
            h=f_head(vec[0].second,rt);
        if(vec[vec.size()-1].first!=vec[vec.size()-2].first)
            h=f_head(vec[vec.size()-1].second,rt);
    }
    
    
    if(!h){
        for(int i=1;i<=n;i++){
            if(con[i]==1){
                h=f_line(i,0);
                if(h){
                    h=i;
                    break;
                }
            }
        }
    }
    if(!h)
        h=rt;
    f_hash(h,0);
    if(f)
        printf("-1\n");
    else
        printf("%d\n",h);
    return 0;
}