Problem:
Score : 600 points

Problem Statement

We have a tree with N vertices numbered 1 to N.
The i-th edge in this tree connects Vertex a_i and Vertex b_i.

Consider painting each of these edges white or black. There are 2^{N-1} such ways to paint the edges. Among them, how many satisfy all of the following M restrictions?

The i-th (1 \leq i \leq M) restriction is represented by two integers u_i and v_i, which mean that the path connecting Vertex u_i and Vertex v_i must contain at least one edge painted black.

Constraints

2 \leq N \leq 50

1 \leq a_i,b_i \leq N

The graph given in input is a tree.

1 \leq M \leq \min(20,\frac{N(N-1)}{2})

1 \leq u_i < v_i \leq N

If i \not= j, either u_i \not=u_j or v_i\not=v_j

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
a_1 b_1
:
a_{N-1} b_{N-1}
M
u_1 v_1
:
u_M v_M

Output

Print the number of ways to paint the edges that satisfy all of the M conditions.

Sample Input 1

3
1 2
2 3
1
1 3

Sample Output 1

3

The tree in this input is shown below:

All of the M restrictions will be satisfied if Edge 1 and 2 are respectively painted (white, black), (black, white), or (black, black), so the answer is 3.

Sample Input 2

2
1 2
1
1 2

Sample Output 2

1

The tree in this input is shown below:

All of the M restrictions will be satisfied only if Edge 1 is painted black, so the answer is 1.

Sample Input 3

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

Sample Output 3

9

The tree in this input is shown below:

Sample Input 4

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

Sample Output 4

62

The tree in this input is shown below:

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <bits/stdc++.h>
using namespace std;
#define int         long long
#define ld          long double
#define endl        "\n"

const int mod = 1e9+7;

inline int add(int a, int b) { int res = a + b; if(res >= mod) res -= mod;  return res; }
inline int sub(int a, int b) { int res = a - b; if(res < 0) res += mod; return res;}
inline int mul(int a, int b) { return (a * b)%mod; }

const int N = 55;
int n, m;
int dep[N];
int fa[N];
int path[22];
vector<int> g[N];

void rec(int u) {
    for(int v : g[u]) if(v != fa[u]) {
        fa[v] = u;
        dep[v] = dep[u] + 1;
        rec(v);
    }
}

void solve() {
    cin >> n;
    for(int i=1; i<n; i++) {
        int u, v; cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    rec(1);
    cin >> m;
    for(int i=0; i<m; i++) {
        int u, v; cin >> u >> v;
        if(dep[u] < dep[v]) swap(u, v);
        while(dep[u] > dep[v]) {
            path[i] |= (1LL << (u - 1));
            u = fa[u];
        }   // Now, both u & v at same level, so find LCA
        while(u != v) {
            path[i] |= (1LL << (u - 1)) | (1LL << (v - 1));
            u = fa[u], v = fa[v];
        }
    }
    int ans = 0;
    for(int i=0; i < (1LL << m); i++) {
        int cnt = 0, white = 0;
        int msk = 0;
        for(int j=0; j<m; j++) if(i & (1LL << j)) cnt++, msk |= path[j];
        for(int j=0; j<n; j++) if(msk & (1LL << j)) white++;
        //ans += (cnt%2 ? -1 : 1) * (1LL << (n - white - 1));
        if(cnt%2) ans -= (1LL << (n - white - 1));
        else ans += (1LL << (n - white -1 ));
    }
    cout << ans << endl;
}

signed main() {

    ios_base::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
    cout << fixed << setprecision(12);

    int T = 1;
    //cin >> T;

    while(T--) {
        solve();
    }
    return 0;
}