无根树同构_hash

先贴上地址 https://vjudge.net/problem/HDU-5732

判断有根树同构:

1. 直接用括号最小表示法

2. 利用括号最小表示法的思想进行hash

判断无根树同构:

1. 找到树的重心.

2. 以重心为根, 把无根树转化成有根树. 按照有根树同构的方法判断是否同构.

同构的过程中,为什么可以sort.

我们知道,对于树来说,

树的节点绕着它的父节点旋转,树的结构就不会被改变的.

所以sort的过程就相当于把树的节点绕着它的父节点进行旋转.

// sort的话,可以这么理解:

我们是按照同样的规则(我们保证这个规则可以唯一确定一棵树,),

对两棵树进行操作,如果同构的话,那么结果应该是一样的. 如果不同构的画 那么结果就是不一样的

至于树的括号表达式, 可以见这几个博客

括号表达式       https://www.byvoid.com/zhs/blog/directed-tree-bracket-sequence

树同构              https://blog.csdn.net/u010152669/article/details/9116975

树的表示方法   https://www.cnblogs.com/jsawz/p/6807636.html

#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <map>
#include <vector>

using namespace std;

typedef unsigned long long ull;
const int maxn = 1e5+;
ull x[maxn];
int ans[maxn];

struct Edge {
    int lst;
    int to;
};

class Tree {
public :
    Edge edge[maxn<<];
    int head[maxn];
    int cn, csz, ccnt, mid[];
    int rcd[maxn];
    ull cnode[maxn];
    ull vvvvv[];
    map<string, int> id;
    char name[maxn][];

    inline void add(int u, int v) {
        edge[csz].lst = head[u];
        edge[csz].to  = v;
        head[u] = csz++;
    }

    int dfs(int u, int fa) {
        int i, v, res = , t1;
        for (i=head[u]; i; i=edge[i].lst) {
            v = edge[i].to;
            if (v == fa) continue;
            t1 = dfs(v, u);
            res += t1;
            if (rcd[u] < t1) rcd[u] = t1;
            if (rcd[v] < cn-t1) rcd[v] = cn-t1;
        }
        return res + ;
    }

    ull dfs2(int u, int fa, int deep) {
        int i, v, res = , t1;
        vector<ull> son;
        for (i=head[u]; i; i=edge[i].lst) {
            v = edge[i].to;
            if (v == fa) continue;
            son.push_back(dfs2(v, u, deep+));
        }
        sort(son.begin(), son.end()); // 判断树同构 注意要sort后乘一个随机数(或者一个质数的i次方).  为什么可以sort呢? 因为树同一层的节点围绕父节点旋转不会改变树的结构. 而sort相当于把节点绕父节点旋转了.
        for (i=, t1=son.size(); i<t1; ++i)
            res += son[i] * x[i+];
        return cnode[u] = (res ? res : x[deep]);
    }

    void init(int n) {
        cn = n; csz = ; id.clear();
        int i, u, v, cnt = ;
        char s1[], s2[];

        for (i=; i<=n; ++i) rcd[i] = head[i] = ;

        for (i=; i<n; ++i) {
            scanf("%s%s", s1, s2);
            if (!(u = id[s1])) {
                strcpy(name[cnt], s1);
                id[s1] = u = cnt++;
            }

            if (!(v = id[s2])) {
                strcpy(name[cnt], s2);
                id[s2] = v = cnt++;
            }
            add(u, v); add(v, u);
        }

        dfs(, -);
        int mm = 0x3f3f3f3f;
        for (i=; i<=n; ++i) {
            if (mm > rcd[i]) {
                mm = rcd[i];
                ccnt = ;
                mid[++ccnt] = i;
            } else if (mm == rcd[i]) mid[++ccnt] = i;
        }

        for (i=; i<=ccnt; ++i)
            vvvvv[i] = dfs2(mid[i], -, );
    }
}te1, te2;

struct nobe {
    int id;
    ull val;
    bool operator < (const nobe &a) const {
        return val < a.val;
    }
    nobe () {}
    nobe (int iid, ull vval) : id(iid), val(vval) {}
};

void dfs3(int u1, int u2, int fa1, int fa2) {
    int i, v1, v2, tsz;
    ans[u1] = u2;
    vector<nobe> ve1, ve2;
    for (i=te1.head[u1]; i; i=te1.edge[i].lst) {
        v1 = te1.edge[i].to;
        if (v1 == fa1) continue;
        ve1.push_back(nobe(v1, te1.cnode[v1]));
    }
    for (i=te2.head[u2]; i; i=te2.edge[i].lst) {
        v2 = te2.edge[i].to;
        if (v2 == fa2) continue;
        ve2.push_back(nobe(v2, te2.cnode[v2]));
    }
    sort(ve1.begin(), ve1.end());
    sort(ve2.begin(), ve2.end());
    for (i=, tsz=ve1.size(); i<tsz; ++i)
        dfs3(ve1[i].id, ve2[i].id, u1, u2);
}

int main()
{
    int i, j, k, n;
    srand(time(NULL));
    for (i=; i<maxn; ++i) x[i] = rand();
    while (~scanf("%d", &n)) {
        te1.init(n);
        te2.init(n);
        for (i=; i<=te1.ccnt; ++i)
            for (j=; j<=te2.ccnt; ++j) {
                if (te1.vvvvv[i] == te2.vvvvv[j]) {
                    dfs3(te1.mid[i], te2.mid[j], te1.mid[i], te2.mid[j]);
                    for (k=; k<=n; ++k)
                        printf("%s %s\n", te1.name[k], te2.name[ans[k]]);
                    goto A;
                }
            }
        A: ;
    }

    return ;
}