[BZOJ4337 BJOI2015 树的同构]树哈希

[BZOJ4337 BJOI2015 树的同构]树哈希

分类：Data Structure Hash template

1. 题目链接

[BZOJ4337 BJOI2015 树的同构]

2. 题意描述

Description
树是一种很常见的数据结构。
我们把N个点，N-1条边的连通无向图称为树。
若将某个点作为根，从根开始遍历，则其它的点都有一个前驱，这个树就成为有根树。
对于两个树T1和T2，如果能够把树T1的所有点重新标号，使得树T1和树T2完全相同，那么这两个树是同构的。也就是说，它们具有相同的形态。
现在，给你M个有根树，请你把它们按同构关系分成若干个等价类。
Input
第一行，一个整数M。
接下来M行，每行包含若干个整数，表示一个树。第一个整数N表示点数。接下来N
个整数，依次表示编号为1到N的每个点的父亲结点的编号。根节点父亲结点编号为0。
Output
输出M行，每行一个整数，表示与每个树同构的树的最小编号。
数据范围：
100% 的数据中， 1≤N,M≤50 。

3. 解题思路

树Hash模板题。

4. 实现代码

#include 
using namespace std;

typedef long long ll;
typedef long double lb;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair pll;
typedef pair puu;
typedef pair pbb;
typedef vector<int> vi;

const int INF = 0x3f3f3f3f;
const ll INFL = 0x3f3f3f3f3f3f3f3fLL;
const long double PI = acos(-1.0);
const long double eps = 1e-4;
template<typename T> inline void umax(T &a, T b) { a = max(a, b); }
template<typename T> inline void umin(T &a, T b) { a = min(a, b); }

void debug() { cout << endl; }
template<typename T, typename ...R> void debug (T f, R ...r) { cout << "[" << f << "]"; debug (r...); }

const int MAXN = 100;
const int MAXE = 200;

ull qz[MAXN];

struct Tree {
    struct Edge {
        int v, next;
    } edge[MAXE];
    int n, head[MAXN], tot, root;
    ull h[MAXN];
    void init() {
        tot = 0;
        memset(head, -1, sizeof(head));
    }
    inline void add_edge(int u, int v) {
        edge[tot] = Edge{v, head[u]};
        head[u] = tot ++;
    }
    void read() {
        scanf("%d", &n);
        int fa;
        for (int i = 1; i <= n; ++i) {
            scanf("%d", &fa);
            if (fa == 0) root = i;
            else {
                add_edge(fa, i);
                add_edge(i, fa);
            }
        }
    }
    int siz[MAXN], mx_sum, g[MAXN], g_cnt;
    void dfs(int u, int fa) {
        int v, temp = 0;
        siz[u] = 1;
        for (int i = head[u]; ~i; i = edge[i].next) {
            v = edge[i].v;
            if (v == fa) continue;
            dfs(v, u);
            siz[u] += siz[v];
            umax(temp, siz[v] + 1);
        }
        umax(temp, n - siz[u] + 1);
        if (temp < mx_sum) {
            mx_sum = temp;
            g_cnt = 0;
            g[g_cnt ++] = u;
        } else if (mx_sum == temp) {
            g[g_cnt ++] = u;
        }
    }
    void hash_dfs(int u, int fa) {
        int v;
        h[u] = siz[u] = 1;
        for (int i = head[u]; ~i; i = edge[i].next) {
            v = edge[i].v;
            if (v == fa) continue;
            hash_dfs(v, u);
            h[u] += h[v] ^ qz[siz[v]];
            siz[u] += siz[v];
        }
        h[u] *= qz[n - siz[u] + 1];
    }
    ull hashV() {
        mx_sum = INF; g_cnt = 0;
        dfs(root, 0);
        ull hv = 1;
        for(int i = 0; i < g_cnt; ++i) {
            hash_dfs(g[i], 0);
            hv *= h[g[i]];
        }
        return hv;
    }
} tr;

int main() {
#ifdef ___LOCAL_WONZY___
    freopen ("input.txt", "r", stdin);
#endif // ___LOCAL_WONZY___
    for (int i = 0; i < MAXN; ++i) qz[i] = (ull) rand() * rand();
    int m;
    while (~scanf("%d", &m)) {
        mapint> mp;
        for (int i = 1; i <= m; ++i) {
            tr.init();
            tr.read();
            ull hv = tr.hashV();
            if (!mp[hv]) mp[hv] = i;
            printf("%d\n", mp[hv]);
        }
    }
#ifdef ___LOCAL_WONZY___
    cout << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC * 1000 << " ms." << endl;
#endif // ___LOCAL_WONZY___
    return 0;
}