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 Scala (2.11.7) (judge verdict: Wrong Answer)

import java.io._
import java.util.StringTokenizer

import scala.collection.mutable.ListBuffer
import scala.reflect.ClassTag

object Main {
  def main(args: Array[String]): Unit = {
    try {
      val (in, out) =
        if (isOnlineJudge) {
          (
            new FastScanner(new InputStreamReader(System.in)),
            new PrintWriter(System.out)
          )
        } else {
          (
            new FastScanner(new FileReader(new File("src/resource/problem.in"))),
            new PrintWriter(new File("src/resource/problem.out"))
          )
        }
      new Abc152E(in, out).solve()
      out.flush()
      out.close()
    } catch {
      case e: IOException => e.printStackTrace()
    }
  }

  private[this] val isOnlineJudge = true

  class FastScanner(val streamReader: InputStreamReader) {
    private[this] val reader = new BufferedReader(streamReader, 32768)
    private[this] var tokenizer: StringTokenizer = _

    @inline private[this] final def next(): String = {
      while (tokenizer == null || !tokenizer.hasMoreTokens)
        tokenizer = new StringTokenizer(reader.readLine)
      tokenizer.nextToken
    }

    def nextInt(): Int = Integer.parseInt(next())

    def nextLong(): Long = java.lang.Long.parseLong(next())

    def nextChar(): Char = next().charAt(0)

    def ni(): Int = nextInt()

    def nl(): Long = nextLong()

    def nc(): Char = nextChar()

    def ns(): String = next()

    def ns(n: Int): Array[Char] = ns().toCharArray

    def na(n: Int, offset: Int = 0): Array[Int] = map(n)(_ => ni() + offset)

    def na2(n: Int, offset: Int = 0): (Array[Int], Array[Int]) = {
      val A1, A2 = Array.ofDim[Int](n)
      REP(n) { i =>
        A1(i) = ni() + offset
        A2(i) = ni() + offset
      }
      (A1, A2)
    }

    def nm(n: Int, m: Int): Array[Array[Int]] = {
      val A = Array.ofDim[Int](n, m)
      REP(n) { i =>
        REP(m) { j =>
          A(i)(j) = ni()
        }
      }
      A
    }

    def nal(n: Int): Array[Long] = map(n)(_ => nl())

    def nm_c(n: Int, m: Int): Array[Array[Char]] = map(n)(_ => ns(m))
  }

  def REP(n: Int, offset: Int = 0)(f: Int => Unit): Unit = {
    var i = offset
    val N = n + offset
    while (i < N) {
      f(i);
      i += 1
    }
  }

  def REP_r(n: Int, offset: Int = 0)(f: Int => Unit): Unit = {
    var i = n - 1 + offset
    while (i >= offset) {
      f(i);
      i -= 1
    }
  }

  def TO(from: Int, to: Int)(f: Int => Unit): Unit = {
    REP(to - from + 1, from)(f)
  }

  def map[@specialized A: ClassTag](n: Int, offset: Int = 0)(f: Int => A): Array[A] = {
    val res = Array.ofDim[A](n)
    REP(n)(i => res(i) = f(i + offset))
    res
  }

  def sumL(as: Array[Int]): Long = {
    var s = 0L
    REP(as.length)(i => s += as(i))
    s
  }

  def cumSum(as: Array[Int]): Array[Long] = {
    val cum = Array.ofDim[Long](as.length + 1)
    REP(as.length) { i =>
      cum(i + 1) = cum(i) + as(i)
    }
    cum
  }
}

class Abc152E(fScanner: Main.FastScanner, out: java.io.PrintWriter) {

  import Main._
  import fScanner._

  def solve(): Unit = {
    val n = ni()
    var ans = 0L
    from = Array.ofDim[Int](n-1)
    to = Array.ofDim[Int](n-1)
    REP(n-1) { i =>
      from(i) = ni()
      to(i) = ni()
    }
    build(n)
    par = Array.fill(n+1, 7)(0)
    height = Array.fill(n+1)(0)
    topo = new ListBuffer[Int]
    dfs(1)
    val m = ni()
    e = Array.ofDim(m, 3)
    REP(m) { i =>
      e(i)(0) = ni()
      e(i)(1) = ni()
      e(i)(2) = lca(e(i)(0), e(i)(1))
    }
    val sum = Array.ofDim[Int](n+1)
    REP(1<<m) { i =>
      0 to n foreach(i => sum(i) = 0)
      var btCount = 0
      REP(m) { j =>
        if((i & (1 << j).toLong) > 0L) {
          btCount +=1
          sum(e(j)(0)) += 1
          sum(e(j)(1)) += 1
          sum(e(j)(2)) -= 2
        }
      }

      topo.foreach{ v =>
        g(v).foreach { u =>
          if(u != par(v)(0)) sum(v) += sum(u)
        }
      }

      var tmp = 0L
      2 to n foreach { j => if(sum(j) == 0) tmp+=1}
      tmp = 1L << tmp
      if(btCount % 2 == 1) tmp = -1 * tmp
      ans += tmp
    }
    out.println(ans)
  }

  def build(n: Int): Unit = {
    val cnt = Array.fill[Int](n+1)(0)
    from.foreach(u => cnt(u) += 1)
    to.foreach(u => cnt(u) += 1)
    g = Array.ofDim[Array[Int]](n+1)
    REP(n+1) { i =>
      g(i) = Array.ofDim[Int](cnt(i))
    }

    REP(n-1) { i =>
      g(from(i))(cnt(from(i))-1) = to(i)
      g(to(i))(cnt(to(i))-1) = from(i)
      cnt(from(i)) -= 1
      cnt(to(i)) -= 1
    }
  }

  def dfs(u: Int): Unit = {
    height(u) = height(par(u)(0)) + 1
    1 until 7 foreach { i =>
      par(u)(i) = par(par(u)(i-1))(i-1)
    }
    g(u).foreach { i =>
      if(i != par(u)(0)) {
        par(i)(0) = u
        dfs(i)
      }
    }
    topo += u
  }

  def lca(_u: Int, _v: Int): Int = {
    var u = _u
    var v = _v
    if(height(u) > height(v)) {
      u = _v; v= _u
    }

    0 until 7 foreach { i =>
      if(((height(v) - height(u)) & (1<<i).toLong) > 0) v = par(v)(i)
    }

    if(u == v) v
    else {
      6 until 0 by -1 foreach { i =>
        if(par(u)(i) != par(v)(i)) {
          u = par(u)(i)
          v = par(v)(i)
        }
      }
      par(u)(0)
    }
  }

  var from: Array[Int] = _
  var to: Array[Int] = _
  var height: Array[Int] = _
  var g: Array[Array[Int]] = _
  var e: Array[Array[Int]] = _
  var par: Array[Array[Int]] = _
  var topo: scala.collection.mutable.ListBuffer[Int] = _
}