[FZOJ195] 「2019冬令营提高组」树（树哈希+DP计数）

题意

• 给你一个$\rm n$个点的树A，一个$\rm m$个点的树B，求A树有多少个不同的生成子图与B同构。（$\rm n \le 2000,m\le12$）

我们首先可以枚举B树是哪个点作为根，B树同构的情况只能算一次，有一个DP就是设$f(i,j)$表示A树上点$i$与B树上点$j$匹配的方案数。我们每次遍历A树的时候多记一个$g(i,S)$表示当前点的前$j$个儿子把$S$集合的点一一对应的方案数，这个东西做一个揹包就可以了。

B树自身子树同构的情况可能会导致一个点被重复匹配，那么对于B中所有深度的子树，假设某个深度有$x$棵同构，那么对与当前点作为根的答案除$x!$即可。

#include<bits/stdc++.h>

#define pb push_back
#define Set(a, b) memset(a, b, sizeof(a))
#define For(i, a, b) for (int i = a; i <= b; ++ i)

using namespace std;
using ull = unsigned long long;

const int M = 12;
const int N = 2e3;
const int Base = 233;
const int mod = 1e9 + 7;

unordered_set<ull> vis;

vector<int> Ga[N + 5];
vector<int> Gb[M + 5];

int n, m, rt, coef, ans;
int g[N + 5][(1 << M) + 5];
int f[N + 5][M + 5], fa[N + 5];

int qpow(int _, int __) { 
	int ___ = 1; 
	for (; __; __ >>= 1, _ = 1ll * _ * _ % mod)
		if (__ & 1) ___ = 1ll * ___ * _ % mod;
	return ___;
}

ull dfs(int u, int dad) {
	vector<ull> S;
	ull res = Base;
	for (auto v : Gb[u]) if (v ^ dad) 
		fa[v] = u, S.pb(dfs(v, u));
	sort(S.begin(), S.end());
	int sz = S.size(), len = 0;
	For(i, 0, sz - 1) {
		if (i && S[i] == S[i - 1]) ++ len;
		else len = 1; 
		res += S[i];
		coef = 1ll * qpow(len, mod - 2) * coef % mod;
	}
	return res * res;
}

void DFS(int u, int dad) { 
	for (auto v : Ga[u]) if (v ^ dad) DFS(v, u);
	For(j, 1, m) { 
		int tp[M + 5], cnt = 0, id = 0, all;
		for (auto v : Gb[j]) if (v ^ fa[j]) tp[++ cnt] = v;
		all = 1 << cnt, g[0][0] = 1;
		for (auto v : Ga[u]) { 
			++ id;
			For(S, 0, all - 1) g[id][S] = g[id - 1][S];
			For(S, 0, all - 1) For(k, 1, cnt) if (S >> (k - 1) & 1)
				(g[id][S] += 1ll * f[v][tp[k]] * g[id - 1][S ^ 1 << (k - 1)] % mod) %= mod;
		}
		(f[u][j] += g[id][all - 1]) %= mod;
		For(k, 0, id) For(S, 0, all - 1) g[k][S] = 0;
	}
}

int main() {

	freopen("tree.in", "r", stdin);
	freopen("tree.out", "w", stdout);

	int x, y;

	scanf("%d", &n);
	For(i, 2, n) { 
		scanf("%d%d", &x, &y);
		Ga[x].pb(y), Ga[y].pb(x);
	}
	scanf("%d", &m);
	For(i, 2, m) {
		scanf("%d%d", &x, &y);
		Gb[x].pb(y), Gb[y].pb(x);
	}

	For(i, 1, m) {
		fa[rt = i] = 0, coef = 1;
		ull hs = dfs(rt, 0);
		if (vis.count(hs)) continue;
		vis.insert(hs), DFS(1, 0);
		For(j, 1, n) (ans += 1ll * coef * f[j][i] % mod) %= mod;
		Set(f, 0);
	}

	cout << ans << endl;

	return 0;
}

// hash B
// 枚举B中每个点为根 贴到A树上 
// f[i][j] A中的i与B中的j 对应的方案数
// 自身儿子同构的话除阶乘。
// g[i][S] 只用前i个点把S中的点对应完的方案数