bzoj4754 [Jsoi2016]独特的树叶 （树同构）

4754: [Jsoi2016]独特的树叶

Time Limit: 10 Sec  Memory Limit: 512 MB
Submit: 168  Solved: 67
[Submit][Status][Discuss]

Description

JYY有两棵树A和B：树A有N个点，编号为1到N；树B有N+1个点，编号为1到N+1。JYY知道树B恰好是由树A加上一个叶节点，然后将节点的编号打乱后得到的。他想知道，这个多余的叶子到底是树B中的哪一个叶节点呢？

Input

输入一行包含一个正整数N。

接下来N-1行，描述树A，每行包含两个整数表示树A中的一条边；

接下来N行，描述树B，每行包含两个整数表示树B中的一条边。

1≤N≤10^5

Output

输出一行一个整数，表示树B中相比树A多余的那个叶子的编号。如果有多个符合要求的叶子，输出B中编号最小的那一个的编号

 

 

枚举$B$中叶子节点，删去后判断是否与$A$同构即可，用哈希实现；

树哈希通常用最小表示法，对于一棵有根树，先给每个点赋一个点权，大小等于它的子树大小；

然后对于一个节点，把它的儿子的哈希值排序后，它的哈希值就等于“它的点权+它的儿子的哈希值”组成的串的哈希值；

因为是无根树，需要加上换根操作，排序后记一下串的前后缀哈希值即可；

AC GET☆DAZE

 

↓代码

#include<algorithm>
#include<iostream>
#include<complex>
#include<cstring>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<map>
#include<set>
#define N 100039
#define mod 20070831
#define inf 0x3f3f3f3f
#define ll unsigned long long
using namespace std;
struct edge
{
    int to,next;
}net[N<<1];
struct poi
{
    int n;
    ll w,suf;
    bool friend operator < (poi a,poi b)
    {
        return a.w<b.w;
    }
};
int n,tot,head[N],siz[N],deg[N];
ll bs[N],hs[N];
vector<poi> son[N];
map<ll,int> mp;
void add(int u,int v)
{
    net[++tot]=(edge){v,head[u]},head[u]=tot,deg[u]++;
    net[++tot]=(edge){u,head[v]},head[v]=tot,deg[v]++;
}
void get_base(ll base,int lim)
{
    bs[0]=1;
    for(int a=1;a<=lim;a++)
    {
        bs[a]=bs[a-1]*base;
    }
}
void calc_hash(int pos,int sz)
{
    sort(son[pos].begin(),son[pos].end());
    hs[pos]=0;
    for(int a=0,b=son[pos].size();a<b;a++)
    {
        hs[pos]+=bs[a+1]*son[pos][a].w;
    }
    hs[pos]+=sz;
}
void dfs(int pos,int pre)
{
    siz[pos]=1;
    for(int a=head[pos];a;a=net[a].next)
    {
        if(net[a].to!=pre)
        {
            dfs(net[a].to,pos);
            siz[pos]+=siz[net[a].to];
            son[pos].push_back((poi){net[a].to,hs[net[a].to],hs[net[a].to]});
        }
    }
    calc_hash(pos,siz[pos]);
}
void change(int pos,int pre,ll hs_pre)
{
    if(pre)
    {
        son[pos].push_back((poi){pre,hs_pre,hs_pre});
        calc_hash(pos,n);
    }
    for(int a=son[pos].size()-2,b=0;~a;a--)
    {
        son[pos][a].suf+=son[pos][a+1].suf*bs[1];
    }
    ll stp=0;
    son[pos].push_back((poi){0,0,0}); 
    for(int a=0,b=son[pos].size()-1;a<b;a++)
    {
        if(son[pos][a].n!=pre)
        {
            change(son[pos][a].n,pos,stp+bs[a+1]*son[pos][a+1].suf+n-siz[son[pos][a].n]);
        }
        stp+=bs[a+1]*son[pos][a].w;
    }
}
void Clear()
{
    tot=0;
    memset(head,0,sizeof(head));
    memset(deg,0,sizeof(deg));
    memset(hs,0,sizeof(hs));
    for(int a=1;a<=n;a++)
    {
        son[a].clear();
    }
}
int main()
{
    scanf("%d",&n);
    get_base(1011139,n);
    for(int a=1,b,c;a<n;a++)
    {
        scanf("%d%d",&b,&c);
        add(b,c);
    }
    dfs(1,0);
    change(1,0,0);
    for(int a=1;a<=n;a++)
    {
        mp[hs[a]]=1;
    }
    Clear(),n++;
    for(int a=1,b,c;a<n;a++)
    {
        scanf("%d%d",&b,&c);
        add(b,c);
    }
    dfs(1,0);
    change(1,0,0);
    for(int a=1;a<=n;a++)
    {
        if(deg[a]==1)
        {
            if(mp[son[net[head[a]].to][1].suf*bs[1]+n-1])
            {
                printf("%d",a);
                break;
            }
        }
    }
    return 0;
}