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 Rust (1.15.1) (judge verdict: Accepted)

const MAX_N: usize = 51;
fn dfs(pos: usize, pre: usize, v: usize, edges: &Vec<Vec<usize>>, paths: &mut Vec<usize>) -> bool {
    if pos == v {
        return true;
    }
    for &nxt in edges[pos].iter() {
        if nxt == pre {
            continue;
        }
        paths.push(nxt);
        let ok = dfs(nxt, pos, v, edges, paths);
        if ok {
            return true;
        }
        paths.pop();
    }
    return false;
}
fn build_path(u: usize, v: usize, edges: &Vec<Vec<usize>>) -> Vec<usize> {
    let mut paths = vec![];
    paths.push(u);
    dfs(u, u, v, edges, &mut paths);
    paths
}
fn memo(
    idx: usize,
    bit: usize,
    m: usize,
    bits: &Vec<Vec<usize>>,
    edges: &Vec<(usize, usize)>,
    dp: &mut Vec<Vec<Option<usize>>>,
) -> usize {
    if idx == edges.len() {
        if bit == (1 << m) - 1 {
            return 1;
        }
        return 0;
    }
    if let Some(value) = dp[idx][bit] {
        return value;
    }
    let mut result = 0;
    let (a, b) = edges[idx];
    //fill
    result += memo(idx + 1, bit | bits[a][b], m, bits, edges, dp);
    result += memo(idx + 1, bit, m, bits, edges, dp);
    dp[idx][bit] = Some(result);
    result
}

fn solve() {
    let s = std::io::stdin();
    let mut sc = Scanner { stdin: s.lock() };
    let n: usize = sc.read();
    let mut edges = vec![vec![]; n];
    let mut n_edges = vec![];
    for _ in 0..n - 1 {
        let a: usize = sc.read();
        let b: usize = sc.read();
        edges[a - 1].push(b - 1);
        edges[b - 1].push(a - 1);
        n_edges.push((a - 1, b - 1));
    }
    let m: usize = sc.read();
    let mut bits = vec![vec![0; MAX_N]; MAX_N];
    for i in 0..m {
        let u: usize = sc.read();
        let v: usize = sc.read();
        let path = build_path(u - 1, v - 1, &edges);
        for x in path.windows(2) {
            bits[x[0]][x[1]] |= 1 << i;
            bits[x[1]][x[0]] |= 1 << i;
        }
    }
    let mut dp = vec![vec![None; 1 << m]; MAX_N];
    let result = memo(0, 0, m, &bits, &n_edges, &mut dp);
    println!("{}", result);
}

fn main() {
    std::thread::Builder::new()
        .stack_size(64 * 1024 * 1024) // 64MB
        .spawn(|| solve())
        .unwrap()
        .join()
        .unwrap();
}

//snippet from kenkoooo
pub struct Scanner<R> {
    stdin: R,
}

impl<R: std::io::Read> Scanner<R> {
    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self
            .stdin
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r')
            .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    pub fn read_line(&mut self) -> String {
        use std::io::Read;
        let buf = self
            .stdin
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b'\n' || b == b'\r')
            .take_while(|&b| b != b'\n' && b != b'\r')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    pub fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read()).collect()
    }

    pub fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}