BZOJ 4337 树的同构（树的hash）

4337: BJOI2015 树的同构

Time Limit: 10 Sec   Memory Limit: 256 MB
Submit: 684   Solved: 282
[ Submit][ Status][ Discuss]

Description

树是一种很常见的数据结构。

我们把N个点，N-1条边的连通无向图称为树。

若将某个点作为根，从根开始遍历，则其它的点都有一个前驱，这个树就成为有根树。

对于两个树T1和T2，如果能够把树T1的所有点重新标号，使得树T1和树T2完全相

同，那么这两个树是同构的。也就是说，它们具有相同的形态。

现在，给你M个有根树，请你把它们按同构关系分成若干个等价类。

Input

第一行，一个整数M。

接下来M行，每行包含若干个整数，表示一个树。第一个整数N表示点数。接下来N

个整数，依次表示编号为1到N的每个点的父亲结点的编号。根节点父亲结点编号为0。

Output

输出M行，每行一个整数，表示与每个树同构的树的最小编号。

Sample Input

4
4 0 1 1 2
4 2 0 2 3
4 0 1 1 1
4 0 1 2 3

Sample Output

1
1
3
1

HINT

【样例解释】 

编号为1, 2, 4 的树是同构的。编号为3 的树只与它自身同构。 

100% 的数据中，1 ≤ N, M ≤ 50。 

题目大意：

    给你m棵树，问哪些同构。

解题思路：

    由于直接比较树的同构实现非常复杂而且时间复杂度高，所以我们先计算出每棵树的hash值，然后直接比较hash值。对于不定根树的hash通常要先确定根节点转化为有向树的hash。由于每棵树的重心最多有两个，所以我们可以把重心作为根节点。

    对于有向树的hash，其中一个比较好的方法就是树的括号序列最小表示法：

定义S[t]表示以t为根的子树的括号序列

S[t]=

{

'(',')' (如果t为叶节点)

'(',S[c1],S[c2],...,S[ck],')' (c1,c2,...,ck为t的k个子节点，S[c1],S[c2],...,S[ck]要按照字典序排列)

}

为了保证同构的树的括号序列表示具有唯一性，我们必须规定子树点的顺序。按照子树的括号序列的字典序就是一种不错的方法。

    以上最小表示法的描述引用这篇博客。显然最小表示法是无损hash，可以在O(n log n)的时间得到，对于结点数较少是非常完美。当结点数较多时，直接使用字符串作为hash结果显然比较慢，使用字符串的有损hash值来代替字符串就可以极大的提高速度。

AC代码：

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <vector>
#include <queue>
#include <stack>
#include <deque>
#include <string>
#include <map>
#include <set>
#include <list>
using namespace std;
#define INF 0x3f3f3f3f
#define LL long long
#define fi first
#define se second
#define mem(a,b) memset((a),(b),sizeof(a))

const int MAXN=50+3;
vector<int> G[MAXN];
int N, M;
int the_max;//重心的最大子树
int subtree_size[MAXN];//以i为根节点的子树的节点数
int max_subtree_size[MAXN];//以i为根节点的最大子树
string h[MAXN];//以i为根的子树的hash值
string tmp_hash[MAXN];//保存当前节点子树的hash值
string ha[MAXN];//第i棵树的最大hash值

void init()//对每棵树的hash做准备
{
    for(int i=1;i<=N;++i)
        G[i].clear();
    the_max=0;
    mem(subtree_size, 0);
    mem(max_subtree_size, 0);
}

void get_root(int u, int fa)//寻找重心
{
    subtree_size[u]=1;
    max_subtree_size[u]=0;
    for(int i=0;i<G[u].size();++i)
    {
        int v=G[u][i];
        if(v==fa)
            continue;
        get_root(v, u);
        subtree_size[u]+=subtree_size[v];
        max_subtree_size[u]=max(max_subtree_size[u], subtree_size[v]);
    }
    max_subtree_size[u]=max(max_subtree_size[u], N-subtree_size[u]);
    the_max=max(the_max, max_subtree_size[u]);
}

void dfs(int u, int fa)//树的最小表示法
{
    h[u]="(";
    for(int i=0;i<G[u].size();++i)
    {
        int v=G[u][i];
        if(v!=fa)
            dfs(v, u);
    }
    int now=0;
    for(int i=0;i<G[u].size();++i)
    {
        int v=G[u][i];
        if(v!=fa)
            tmp_hash[now++]=h[v];
    }
    sort(tmp_hash, tmp_hash+now);
    for(int i=0;i<now;++i)
        h[u]+=tmp_hash[i];
    h[u]+=')';
}

string get_hash()
{
    get_root(1, 0);
    string tmp="";
    for(int i=1;i<=N;++i)
        if(max_subtree_size[i]==the_max)
        {
            dfs(i, 0);
            tmp=max(tmp, h[i]);//如果有多个重心，取字典序最大的
        }
    return tmp;
}

int main()
{
    scanf("%d", &M);
    for(int i=1;i<=M;++i)
    {
        scanf("%d", &N);
        init();
        for(int i=1;i<=N;++i)
        {
            int tmp;
            scanf("%d", &tmp);
            if(tmp)
            {
                G[i].push_back(tmp);
                G[tmp].push_back(i);
            }
        }
        ha[i]=get_hash();
    }
    for(int i=1;i<=M;++i)//暴力比较任意两棵树的hash值
        for(int j=1;j<=i;++j)
            if(ha[i]==ha[j])
            {
                printf("%d\n", j);
                break;
            }
    
    return 0;
}