4337: BJOI2015 树的同构

4337: BJOI2015 树的同构

Time Limit: 10 Sec   Memory Limit: 256 MB
Submit: 171   Solved: 81
[ 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。 

Source

[ Submit][ Status][ Discuss]



HASH乱搞。。

每棵子树的hash值等于将其所有子树hash值排序后 h[i] = h[i]*hash+h[j]

h[i]初始='(' 最后再加个')'

用每棵树的每个点都尝试作为根，都会得到一个hash，将他们排序

两棵树同构当且仅当从小到大所有hash相同

总之，hash乱来，hash值足够多出错概率就越低

#include<iostream>
#include<cstdio>
#include<queue>
#include<vector>
#include<algorithm>
#include<cstring>
using namespace std;

typedef unsigned long long UL;
const UL hash = 233;

const int maxn = 55;

UL h[maxn],ha[maxn][maxn];
int m,siz[maxn],ma,o1,o2,s;
bool vis[maxn];

vector <int> v[maxn];

void solve(int k,int fa)
{
	bool flag = 1;
	vector <UL> H;
	for (int i = 0; i < v[k].size(); i++) {
		int to = v[k][i];
		if (to == fa) continue;
		flag = 0;
		solve(to,k);
		H.push_back(h[to]);
	}
	sort(H.begin(),H.end());
	if (flag) h[k] = hash;
	else {
		h[k] = '(';
		for (int i = 0; i < H.size(); i++) {
			h[k] = h[k]*hash+H[i];
		 }
	}
	h[k] += ')';
}

int main()
{
	#ifdef YZY
		freopen("yzy.txt","r",stdin);
	#endif
	
	cin >> m;
	for (int i = 1; i <= m; i++) {
		int n; scanf("%d",&n);
		for (int j = 1; j <= n; j++) v[j].clear();
		int root;
		for (int j = 1; j <= n; j++) {
			int x; scanf("%d",&x);
			if (x) {
				v[x].push_back(j);
				v[j].push_back(x);
			}
			else root = i;
		}	
		
		for (int j = 1; j <= n; j++) {
			memset(h,0,sizeof(h));
			solve(j,0);
			ha[i][j] = h[j];
		}
		sort(ha[i] + 1,ha[i] + n + 1);
		
		int ans = i;
		for (int j = 1; j < i; j++) {
			bool flag = 1;
			for (int l = 1; l <= n; l++) 
				if (ha[j][l] != ha[i][l]) {
					flag = 0; break;
				}
			if (flag) {
				ans = j; break;
			}
		}
		printf("%d\n",ans);
	}
	return 0;
}