BZOJ 4337 树的同构

    很明显，这应该是一道模版题（因为我很快就在一本书上找到了这道题的模版），不过令我比较奇怪的大概是有根树和无根树的概念，以及在这道题目中根有卵用吗？ （看来树这一块的知识还是要补一下）。 树的同构很明显应该是用hash来判断的，当然了，不同的人设计的hash函数不同了。这道题正确的应该是要在树的重心上面跑这道题的模版，（如果你要问我树的重心是啥，我只能跟你说，如果我知道的话，下面这份代码就不会把几乎所有的点都跑一次了，但是由于N<=50,M <= 50 很明显这样跑完还是很快的，事实证明也只跑了32毫秒，但本着求真务实的心态，找个时间再补下树吧！）。很明显，尽管两棵树的形态完全相同，但如果从不同的节点开始跑这个模版，所得的hash值也会不同。所以正确的是要在几乎唯一的重心上跑(据说，一棵有根树的重心最多有两个)。加油吧！相信自己。（我是一条可耻的源程狗）。

#include<cstdio>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<algorithm>
#define ull unsigned long long
#define magic 107ull
#define rep(i,j,k) for(int i = j; i <= k; i++)
#define maxn 60
using namespace std;

int read()
{
    int s = 0, t = 1; char c = getchar();
    while( !isdigit(c) ){
        if( c == '-' ) t = -1; c = getchar();
    }
    while( isdigit(c) ){
        s = s * 10 + c -'0'; c = getchar();
    }
    return s * t;
}

ull pow(ull key,int n)
{
    ull ret = 1ull;
    while( n ){
       if( n & 1 ){
             ret *= key;
       }
       key *= key, n >>= 1;
    }
    return ret;
}

struct hash{
int length; ull key;

hash(): length(0), key(0) {}
hash(char c): length(1), key(c) {}
hash(int l,ull key): length(l), key(key) {}
};
vector<hash> childs[maxn];

bool operator < (const hash&a, const hash&b){
    return a.key < b.key;
}

hash operator + (const hash&a, const hash& b){
    return hash(a.length+b.length,a.key*pow(magic,b.length)+b.key);
}

void operator += (hash&a,const hash&b){
    a = a + b;
}

vector<int> g[maxn];

hash dfs(int pre,int now)
{
    hash ret;
    childs[now].clear(); int s = g[now].size();
    rep(i,0,s-1){
        int to = g[now][i];
        if( to == pre ) continue;
        childs[now].push_back(dfs(now,to));
    }
    sort(childs[now].begin(),childs[now].end());
    for(vector<hash>::iterator iter = childs[now].begin(); iter != childs[now].end(); iter++){
        ret += *iter;
    }
    ret = '(' +  ret + ')';
    return ret;
    
}

ull gethash(int root)
{
    return dfs(-1,root).key;
}

set<ull> s;
map<ull,int> mp; 

void clear()
{
    rep(i,1,maxn) g[i].clear();
}

int main()
{
    int n = read();
    rep(i,1,n){
        clear(); s.clear();
        int m = read();
        rep(j,1,m){
            int x = read();
            if( x ) g[j].push_back(x), g[x].push_back(j);
        }
        bool ok = 0;
        rep(j,1,m){
            ull key = gethash(j);
            if( mp[key] ) {
                printf("%d\n", mp[key]);
                ok = 1;
                break;
            }
            else s.insert(key);
        } 
        if( !ok ){
            printf("%d\n", i);
            for(set<ull>::iterator iter = s.begin(); iter != s.end(); iter++ ){
                mp[*iter] = i;
            }
        }
    }
    return 0;
}

 

好了，这是加了找重心优化的树的同构（思想很简单，就是让所有的一个或两个重心去跑，然后取最大的，就这样）（20毫秒） 加油，多学多练。

#include<cstdio>
#include<iostream>
#include<vector>
#include<map>
#include<algorithm>
#define ull unsigned long long
#define magic 107ull
#define rep(i,j,k) for(int i = j; i <= k; i++)
#define maxn 60
using namespace std;

int read()
{
    int s = 0, t = 1; char c = getchar();
    while( !isdigit(c) ){
        if( c == '-' ) t = -1; c = getchar();
    }
    while( isdigit(c) ){
        s = s * 10 + c -'0'; c = getchar();
    }
    return s * t;
}

ull pow(ull key,int n)
{
    ull ret = 1ull;
    while( n ){
       if( n & 1 ){
             ret *= key;
       }
       key *= key, n >>= 1;
    }
    return ret;
}

struct hash{
int length; ull key;

hash(): length(0), key(0) {}
hash(char c): length(1), key(c) {}
hash(int l,ull key): length(l), key(key) {}
};
vector<hash> childs[maxn];

bool operator < (const hash&a, const hash&b){
    return a.key < b.key;
}

hash operator + (const hash&a, const hash& b){
    return hash(a.length+b.length,a.key*pow(magic,b.length)+b.key);
}

void operator += (hash&a,const hash&b){
    a = a + b;
}

vector<int> g[maxn];

hash dfs(int pre,int now)
{
    hash ret;
    childs[now].clear(); int s = g[now].size();
    rep(i,0,s-1){
        int to = g[now][i];
        if( to == pre ) continue;
        childs[now].push_back(dfs(now,to));
    }
    sort(childs[now].begin(),childs[now].end());
    for(vector<hash>::iterator iter = childs[now].begin(); iter != childs[now].end(); iter++){
        ret += *iter;
    }
    ret = '(' +  ret + ')';
    return ret;
    
}

ull gethash(int root)
{
    return dfs(-1,root).key;
}

map<ull,int> mp; 

void clear()
{
    rep(i,1,maxn) g[i].clear();
}

int son[maxn], f[maxn], m,  mx;
void find_root(int pre,int now)
{
    son[now] = 1, f[now] = 0; int s = g[now].size();
    rep(i,0,s-1){
        int to = g[now][i];
        if( to != pre ){
            find_root(now,to);
            son[now] += son[to];
            if( son[to] > f[now] ) f[now] = son[to];
        }
    }
    if( m - son[now] > f[now] ) f[now] = m - son[now];
    if( f[now] < mx ) mx = f[now];
}

int main()
{
    int n = read();
    rep(i,1,n){
        clear(); 
        m = read(); mx = 0x7ffffff;
        rep(j,1,m){
            int x = read();
            if( x ) g[j].push_back(x), g[x].push_back(j);
        }
        find_root(0,1); ull key = 0;
        rep(j,1,m){
            if( f[j] == mx ) {
                ull value = gethash(j);
                if( value > key ) key = value;
            }
        }
        if( mp[key] ) printf("%d\n", mp[key]);
        else {
            printf("%d\n", i);
            mp[key] = i;
        }
    }
    return 0;
}