CodeForces 762F. Tree nesting

You are given two trees (connected undirected acyclic graphs) S and T.

Count the number of subtrees (connected subgraphs) of S that are isomorphic to tree T. Since this number can get quite large, output it modulo 109 + 7.

Two subtrees of tree S are considered different, if there exists a vertex in S that belongs to exactly one of them.

Tree G is called isomorphic to tree H if there exists a bijection f from the set of vertices of G to the set of vertices of H that has the following property: if there is an edge between vertices A and B in tree G, then there must be an edge between vertices f(A) and f(B) in tree H. And vice versa — if there is an edge between vertices A and B in tree H, there must be an edge between f - 1(A) and f - 1(B) in tree G.

Input

The first line contains a single integer |S| (1 ≤ |S| ≤ 1000) — the number of vertices of tree S.

Next |S| - 1 lines contain two integers ui and vi (1 ≤ ui, vi ≤ |S|) and describe edges of tree S.

The next line contains a single integer |T| (1 ≤ |T| ≤ 12) — the number of vertices of tree T.

Next |T| - 1 lines contain two integers xi and yi (1 ≤ xi, yi ≤ |T|) and describe edges of tree T.

Output

On the first line output a single integer — the answer to the given task modulo 109 + 7.

Examples

input

5
1 2
2 3
3 4
4 5
3
1 2
2 3

output

3

input

3
2 3
3 1
3
1 2
1 3

output

1

input

7
1 2
1 3
1 4
1 5
1 6
1 7
4
4 1
4 2
4 3

output

20

input

5
1 2
2 3
3 4
4 5
4
4 1
4 2
4 3

output

0

题意：给定两棵树S,T，求S有多少个连通子图与T同构

吐槽：必须吐槽，这里的subtree不是指子树，而是指连通子图......

题解：状压DP

dp[i][j]表示S中i的子树和右兄弟（不包括i）完成T的状态为j的方案数

对于T预处理bit数组，表示它的儿子状压后的表示

然后S可以直接以1为根，枚举T的根即可

dfs(f,y,V)表示f的第y个儿子，状态为V方便转移

记忆化搜索即可

答案就是S与T同构/T自同构

复杂度O( ( |T| ^ 2 ) * ( 2^ |T| ) * |S| )

#include <bits/stdc++.h>

using namespace std;

const int MAXN = 1001;
const int MAXV = 1 << 12;
const int mod = 1e9 + 7;

inline int Pow(int x, int y)
{
	int s = 1;
	for( ; y ; y >>= 1, x = 1ll * x * x % mod ) if( y & 1 ) s = 1ll * s * x % mod;
	return s;
}

inline int inv(int x) { return Pow( x, mod - 2 ); }

struct edge { int to, nxt; };

struct tree
{
	edge e[MAXN << 1];
	int n, cnt;
	int head[MAXN], son[MAXN][MAXN], size[MAXN], bit[MAXN];
	inline void addedge(int x, int y) { e[ ++cnt ].to = y; e[ cnt ].nxt = head[ x ]; head[ x ] = cnt; }
	inline void read()
	{
		scanf( "%d", &n );
		for( int i = 1 ; i < n ; i++ ) { int x, y; scanf( "%d%d", &x, &y ); addedge( x, y ); addedge( y, x ); }
	}
	inline void dfs(int x, int fa)
	{
		size[ x ] = bit[ x ] = 0;
		for( int i = head[ x ] ; i ; i = e[ i ].nxt ) if( e[ i ].to ^ fa )
			dfs( son[ x ][ ++size[ x ] ] = e[ i ].to, x ), bit[ x ] |= 1 << e[ i ].to - 1; 
	}
}S, T;

int dp[MAXN][MAXV], ans, ans2;

bool vis[MAXN][MAXV];

inline int dfs(int f, int y, int V)
{
	if( !y ) return !V;
	int x = S.son[ f ][ y ];
	if( vis[ x ][ V ] ) return dp[ x ][ V ];
	vis[ x ][ V ] = 1;
	int &ret = dp[ x ][ V ];
	ret = dfs( f, y - 1, V );
	for(int i = 0 ; i < T.n ; i++ ) if( V >> i & 1 )
		ret = ( 1ll * dfs( f, y - 1, V ^ ( 1 << i ) ) * dfs( x, S.size[ x ], T.bit[ i + 1 ] ) + ret ) % mod;
	return ret; 
}

int main()
{
	S.read();
	T.read();
	S.dfs( 1, 0 );
	for( int i = 1 ; i <= T.n ; i++ )
	{
		memset( dp, 0, sizeof dp );
		memset( vis, 0, sizeof vis );
		T.dfs( i, 0 );
		for( int j = 1 ; j <= S.n ; j++ ) ( ans += dfs( j, S.size[ j ], T.bit[ i ] ) ) %= mod;
	}
	S = T;
	S.dfs( 1, 0 );
	for( int i = 1 ; i <= T.n ; i++ )
	{
		memset( dp, 0, sizeof dp );
		memset( vis, 0, sizeof vis );
		T.dfs( i, 0 );
		( ans2 += dfs( 1, S.size[ 1 ], T.bit[ i ] ) ) %= mod;
	}
	ans = 1ll * ans * inv( ans2 ) % mod;
	return printf( "%d\n", ans ), 0;
}