枚举两个数的第一位和最后一位，以及位数即可。

由于有边界，我还写了一个二分找固定了第一位、最后一位、位数后有多少个满足条件，写的很不优雅。

算算我的复杂度 $O(100\ast bi{t}^2\ast \log n)$

不够优雅。

最优值显然就是所有值的 $LCM$ ，但是值很大。我们考虑素因数分解。然后利用同余计算出模后的 $LCM$。最后利用逆元即可算出模后的 $B_i$。

考虑的 $M$ 比较小，我看错了，还在想有什么黑科技。显然正着去计算不太现实，那么我们考虑反面，即不满足条件的有多少个，总数减去不满足即可。

总数显然是 $2^{n-1}$ ，每条边两种情况嘛，那么我们如何计算不满足的呢，这就是经典容斥了，把不满足某个约束当特征，就能很容易的算出来。

然后我们考虑如何优雅的写，最好的方法是二进制压缩，当前约束需要的边的集合，这样同时满足几个约束，就是集合取并集。之后就是一些简单的组合数学下细节了。当然还有黑科技 __builtin_popcountll

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

ll qp(ll x,ll p)
{
	ll res = 1;
	while (p)
	{
		if (p & 1) res = x * res;
		p >>= 1;
		x = 1ll * x * x;
	}
	return res;
}

void sol()
{
	int n, u, v, m;
	cin >> n;
	ll path[56][56] = {0};
	int edge[56][56] = {0};
	for (int i = 1; i < n; ++i)
	{
		cin >> u >> v;
		edge[u][v] = edge[v][u] = i;
	}
	for (int i = 1; i <= n; ++i)
	{
		queue<int> q;
		q.push(i);
		while (!q.empty())
		{
			u = q.front();
			q.pop();
			for (v = 1; v <= n; ++v)
			{
				if (edge[u][v] > 0)
				{
					if (!path[i][v])
					{
						path[i][v] = path[i][u] | (1ll << edge[u][v]);
						q.push(v);
					}
				}
			}
		}
	}
	cin >> m;
	vector<int> l(m),r(m);
	for (int i = 0; i < m; ++i)
		cin >> l[i] >> r[i];
	ll ans = qp(2,n - 1);
	for (int i = 1; i < (1 << m); ++i)
	{
		int p = 1;
		ll tp = 0;
		for (int j = 0; j < m; ++j)
		{
			if ((i >> j) & 1)
			{
				p *= -1;
				tp |= path[l[j]][r[j]];
			}
		}
		int k = n - __builtin_popcountll(tp) - 1;
		ans += p * qp(2, k);
	}
	cout << ans << endl;
	
}

int main()
{
	int T = 1;
	while (T--) sol();
	return 0;
}