uva12489 Combating cancer(树同构)

转载请注明出处： http://www.cnblogs.com/fraud/          ——by fraud

https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=3933

给你两棵无根树，让你判断这两棵树是否同构

不会判断树同构，果断抄了个模板，乱搞给过掉了。

首先由于给的是无根树，而要判断无根树是否同构得以重心为根，然后做一个括号序列的哈希。

于是我们需要先找出重心，要找树的重心得先知道直径。

找出直径，直径上的点的个数是偶数，那么重心是中间的两个点，如果是奇数个，那么重心是中间那个。

或者说是根据拓排，每次度数为1的点入队，留下的最后一批就是。

然而我当时脑抽了一下，求好直径，后用第二种再去搞。。。其实求直径的时候保存一下路径就好了。

最后，如果有两个重心就做两次哈希，得到两个哈希值，一个就一次。

最后把两棵树的哈希值比一下是否有相同的。

/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author xyiyy @https://github.com/xyiyy
 */
 
#include <iostream>
#include <fstream>
 
//#####################
//Author:fraud
//Blog: http://www.cnblogs.com/fraud/
//#####################
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <iostream>
#include <sstream>
#include <ios>
#include <iomanip>
#include <functional>
#include <algorithm>
#include <vector>
#include <string>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <climits>
#include <cctype>
 
using namespace std;
#define pb(X) push_back(X)
#define rep(X, N) for(int X=0;X<N;X++)
#define ALL(X) (X).begin(),(X).end()
typedef unsigned long long ull;
 
const int maxNode = ;
const int maxEdge = (maxNode << );
//
// Created by xyiyy on 2015/8/14.
//
 
#ifndef ICPC_HASHTREE_HPP
#define ICPC_HASHTREE_HPP
 
//树的同构，返回哈希值
//输入有根树的根，或者无根树的重心
typedef unsigned long long ull;
const ull MAGIC = ;
 
//
// Created by xyfra_000 on 2015/8/14.
//
 
#ifndef ICPC_ADJLIST_ARRAY_HPP
#define ICPC_ADJLIST_ARRAY_HPP
 
#define Foredge(A, X) for(int A = From[X];A!=-1;A = Next[A])
 
int From[maxEdge], To[maxEdge];
int Next[maxEdge];
int Edgecnt;
 
void init(int n) {
    rep(i, n + )From[i] = -;
    Edgecnt = ;
}
 
void addedge(int u, int v) {
    To[Edgecnt] = v;
    Next[Edgecnt] = From[u];
    From[u] = Edgecnt++;
}
 
#endif //ICPC_ADJLIST_ARRAY_HPP
 
ull powMod(ull a, int n) {
    ull ret = 1ULL;
    while (n) {
        if (n & )ret *= a;
        a *= a;
        n >>= ;
    }
    return ret;
}
 
struct Hash {
    int length;
    ull value;
 
    Hash() : length(), value() { }
 
    Hash(char c) : length(), value(c) { }
 
    Hash(int l, int v) : length(l), value(v) { }
};
 
bool operator<(const Hash &a, const Hash &b) {
    return a.value < b.value;
}
 
Hash operator+(const Hash &a, const Hash &b) {
    return Hash(a.length + b.length, a.value * powMod(MAGIC, b.length) + b.value);
}
 
void operator+=(Hash &a, Hash &b) {
    a = a + b;
}
 
vector<Hash> childs[maxNode];
 
Hash dfs(int pre, int cur) {
    Hash ret;
    childs[cur].clear();
    for (int iter = From[cur]; iter != -; iter = Next[iter]) {
        if (To[iter] != pre) {
            childs[cur].pb(dfs(cur, To[iter]));
        }
    }
    sort(ALL(childs[cur]));
    for (vector<Hash>::iterator iter = childs[cur].begin(); iter != childs[cur].end(); iter++) {
        ret += *iter;
    }
    Hash retL = Hash('(');
    ret = '(' + ret + ')';
    return ret;
}
 
ull getHash(int root) {
    return dfs(-, root).value;
}
 
#endif //ICPC_HASHTREE_HPP
 
//
// Created by xyfra_000 on 2015/8/14.
//
 
#ifndef ICPC_TREEDIAMETER_HPP
#define ICPC_TREEDIAMETER_HPP
 
//求树的直径
//可以通过修改dfs部分变成求带权的树的直径
 
vector<int> dist;
 
void dfs(int p, int u, int d) {
    dist[u] = d;
    Foredge(i, u) {
        if (To[i] != p) {
            dfs(u, To[i], d + );
        }
    }
}
 
int getDiameter(int n) {
    dist.resize(n);
    dfs(-, , );
    int u = max_element(ALL(dist)) - dist.begin();
    dfs(-, u, );
    return *max_element(ALL(dist));
}
 
#endif //ICPC_TREEDIAMETER_HPP
 
int deg[maxNode];
int vis[maxNode];
 
class TaskH {
public:
    void solve(std::istream &in, std::ostream &out) {
        int n;
        while (in >> n) {
            vector<ull> ans[];
            rep(times, ) {
                int u, v;
                init(n);
                rep(i, n + )deg[i] = ;
                rep(i, n + )vis[i] = ;
                queue<int> q;
                rep(i, n - ) {
                    in >> u >> v;
                    u--, v--;
                    deg[u]++;
                    deg[v]++;
                    addedge(u, v);
                    addedge(v, u);
                }
                int dia = getDiameter(n);
                int num = n;
                rep(i, n) {
                    if (deg[i] == ) {
                        q.push(i);
                    }
                }
                int gao = ;
                if (dia & )gao++;
                while (num > gao && !q.empty()) {
                    u = q.front();
                    q.pop();
                    vis[u] = ;
                    num--;
                    deg[u]--;
                    for (int i = From[u]; i != -; i = Next[i]) {
                        int v = To[i];
                        if (!vis[v]) {
                            deg[v]--;
                            if (deg[v] == ) {
                                q.push(v);
                            }
                        }
                    }
                }
                rep(i, n) {
                    if (!vis[i]) {
                        ans[times].pb(getHash(i));
                    }
                }
            }
            bool ok = ;
            rep(i, ans[].size()) {
                rep(j, ans[].size()) {
                    if (ans[][i] == ans[][j])ok = ;
                }
            }
            if (ok)out << "S" << endl;
            else out << "N" << endl;
        }
    }
};
 
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie();
    TaskH solver;
    std::istream &in(std::cin);
    std::ostream &out(std::cout);
    solver.solve(in, out);
    return ;
}