```go
package main

import (
	"bufio"
	"io"
	"os"
	"sort"
	"strconv"
)

var (
	n    int
	LG   int
	tin  []int
	tout []int
	up   [][]int
)

func isAncestor(u, v int) bool {
	return tin[u] <= tin[v] && tout[v] <= tout[u]
}

func lca(u, v int) int {
	if isAncestor(u, v) {
		return u
	}
	if isAncestor(v, u) {
		return v
	}
	for i := LG - 1; i >= 0; i-- {
		pu := up[i][u]
		if pu != 0 && !isAncestor(pu, v) {
			u = pu
		}
	}
	return up[0][u]
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	nextInt := func() int {
		for idx < len(data) && (data[idx] < '0' || data[idx] > '9') {
			idx++
		}
		val := 0
		for idx < len(data) && data[idx] >= '0' && data[idx] <= '9' {
			val = val*10 + int(data[idx]-'0')
			idx++
		}
		return val
	}

	n = nextInt()
	adj := make([][]int, n+1)
	for i := 0; i < n-1; i++ {
		u := nextInt()
		v := nextInt()
		adj[u] = append(adj[u], v)
		adj[v] = append(adj[v], u)
	}

	LG = 1
	for (1 << LG) <= n {
		LG++
	}

	tin = make([]int, n+1)
	tout = make([]int, n+1)
	up = make([][]int, LG)
	for i := 0; i < LG; i++ {
		up[i] = make([]int, n+1)
	}

	type Frame struct {
		v, p, state int
	}

	timer := 0
	stack := make([]Frame, 0, 2*n)
	stack = append(stack, Frame{1, 0, 0})
	for len(stack) > 0 {
		fr := stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		v, p, state := fr.v, fr.p, fr.state
		if state == 0 {
			timer++
			tin[v] = timer
			up[0][v] = p
			for i := 1; i < LG; i++ {
				up[i][v] = up[i-1][up[i-1][v]]
			}
			stack = append(stack, Frame{v, p, 1})
			for _, to := range adj[v] {
				if to != p {
					stack = append(stack, Frame{to, v, 0})
				}
			}
		} else {
			tout[v] = timer
		}
	}

	q := nextInt()
	imp := make([]int, n+1)
	vtParent := make([]int, n+1)
	cntActive := make([]int, n+1)

	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	qid := 0

	for ; q > 0; q-- {
		qid++
		k := nextInt()
		arr := make([]int, k)
		for i := 0; i < k; i++ {
			v := nextInt()
			arr[i] = v
			imp[v] = qid
		}

		bad := false
		for _, v := range arr {
			p := up[0][v]
			if p != 0 && imp[p] == qid {
				bad = true
				break
			}
		}

		if bad {
			out.WriteString("-1\n")
			continue
		}

		sort.Slice(arr, func(i, j int) bool {
			return tin[arr[i]] < tin[arr[j]]
		})

		all := make([]int, 0, 2*k)
		all = append(all, arr...)
		for i := 0; i+1 < k; i++ {
			all = append(all, lca(arr[i], arr[i+1]))
		}

		sort.Slice(all, func(i, j int) bool {
			return tin[all[i]] < tin[all[j]]
		})

		m := 0
		for _, v := range all {
			if m == 0 || all[m-1] != v {
				all[m] = v
				m++
			}
		}
		all = all[:m]

		st := make([]int, 0, m)
		st = append(st, all[0])
		vtParent[all[0]] = 0

		for i := 1; i < m; i++ {
			v := all[i]
			for !isAncestor(st[len(st)-1], v) {
				st = st[:len(st)-1]
			}
			vtParent[v] = st[len(st)-1]
			st = append(st, v)
		}

		ans := 0
		for i := m - 1; i >= 0; i-- {
			v := all[i]
			cnt := cntActive[v]
			active := 0
			if imp[v] == qid {
				ans += cnt
				active = 1
			} else {
				if cnt > 1 {
					ans++
				} else if cnt == 1 {
					active = 1
				}
			}
			p := vtParent[v]
			if p != 0 {
				cntActive[p] += active
			}
		}

		out.WriteString(strconv.Itoa(ans))
		out.WriteByte('\n')

		for _, v := range all {
			vtParent[v] = 0
			cntActive[v] = 0
		}
	}

	out.Flush()
}
```