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 Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.io.*;
import java.util.*;
 
public class Main {

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		PrintWriter pw = new PrintWriter(System.out);
		int N = sc.ni();
		int[][] edges = new int[N-1][2];
		ArrayList<Edge>[] tree = new ArrayList[N];
		for (int i = 0; i < N; i++) {
			tree[i] = new ArrayList<Edge>();
		}
		for (int i = 0; i < N-1; i++) {
			edges[i][0] = sc.ni()-1;
			edges[i][1] = sc.ni()-1;
			tree[edges[i][0]].add(new Edge(edges[i][1],i));
			tree[edges[i][1]].add(new Edge(edges[i][0],i));
		}
		int M = sc.ni();
		long[] path = new long[M];
		for (int i = 0; i < M; i++) {
			int u = sc.ni()-1;
			int v = sc.ni()-1;
			int[] prev = new int[N];
			int[] takeEdge = new int[N];
			boolean[] vis = new boolean[N];
			vis[u] = true;
			Arrays.fill(prev,-1);
			Arrays.fill(takeEdge,-1);
			ArrayDeque<Integer> bfs = new ArrayDeque<Integer>();
			bfs.add(u);
			while (! bfs.isEmpty()) {
				int node = bfs.poll();
				for (Edge next: tree[node]) {
					if (! vis[next.to]) {
						vis[next.to] = true;
						prev[next.to] = node;
						takeEdge[next.to] = next.index;
						bfs.add(next.to);
					}
				}
			}
			
			int n = v;
			while (n != u) {
				long bit = (long)takeEdge[n];
				path[i] += (1<<bit);
				n = prev[n];
			}
		}
		
		long[] dp = new long[1<<M]; //The bitmask of the required edges that must be painted white in order to fail certain restrictions.
		long[] cnt = new long[1<<M]; //the number of possible colorings to satisfy the dp.
		for (int i = 0; i < M; i++) {
			dp[1<<i] = path[i];
			cnt[1<<i] = (1<<((long)((N-1)-Long.bitCount(path[i]))));
		}
		for (int i = 1; i < dp.length; i++) {
			if (dp[i] > 0) continue;
			//Let i = "10111100"
			int right = Integer.lowestOneBit(i); //100
			int left = i-right; //10111000
			dp[i] = (dp[left]|dp[right]);
			cnt[i] = (1<<((long)((N-1)-Long.bitCount(dp[i]))));
		}
		
		//pw.println(Arrays.toString(cnt));
		
		//Inclusion Exclusion
		long badCases = 0;
		for (int i = 1; i < dp.length; i++) {
			if (Long.bitCount(i) % 2 == 0) {
				badCases -= cnt[i];
			} else {
				badCases += cnt[i];
			}
		}
		long totalCases = (1<<((long)(N-1)));
		pw.println(totalCases-badCases);
		pw.close();
	}
	
	static class Edge {
		public int to;
		public int index;
		public Edge (int t, int i) {
			to = t;
			index = i;
		}
	}
    
    static class FastScanner { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastScanner() { 
            br = new BufferedReader(new InputStreamReader(System.in)); 
        } 
  
        String next() { 
            while (st == null || !st.hasMoreElements()) { 
                try { 
                    st = new StringTokenizer(br.readLine());
                } catch (IOException  e) { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 
  
        int ni() { 
            return Integer.parseInt(next()); 
        } 
  
        long nl() { 
            return Long.parseLong(next()); 
        } 
  
        double nd() { 
            return Double.parseDouble(next()); 
        } 
  
        String nextLine() { 
            String str = ""; 
            try { 
                str = br.readLine(); 
            } catch (IOException e) {
                e.printStackTrace(); 
            } 
            return str;
        }
    }
}