package main

import (
	"bufio"
	"io"
	"os"
	"strings"
)

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data, n: len(data)}
}

func (fs *FastScanner) NextInt() int {
	for fs.idx < fs.n && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
	sign := 1
	if fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	val := 0
	for fs.idx < fs.n {
		b := fs.data[fs.idx]
		if b < '0' || b > '9' {
			break
		}
		val = val*10 + int(b-'0')
		fs.idx++
	}
	return val * sign
}

type Frame struct {
	v int
	p int
	e int
}

func main() {
	fs := NewFastScanner()
	n := fs.NextInt()
	m := fs.NextInt()

	head := make([]int, n+1)
	for i := 1; i <= n; i++ {
		head[i] = -1
	}
	to := make([]int, 2*(n-1))
	next := make([]int, 2*(n-1))
	edgeIdx := 0

	addEdge := func(u, v int) {
		to[edgeIdx] = v
		next[edgeIdx] = head[u]
		head[u] = edgeIdx
		edgeIdx++
	}

	for i := 0; i < n-1; i++ {
		u := fs.NextInt()
		v := fs.NextInt()
		addEdge(u, v)
		addEdge(v, u)
	}

	parent := make([]int, n+1)
	depth := make([]int, n+1)
	tin := make([]int, n+1)
	tout := make([]int, n+1)

	timer := 0
	parent[1] = 1
	tin[1] = timer
	timer++

	stack := make([]Frame, 0, n)
	stack = append(stack, Frame{v: 1, p: 0, e: head[1]})

	for len(stack) > 0 {
		top := &stack[len(stack)-1]
		if top.e != -1 {
			ei := top.e
			top.e = next[ei]
			u := to[ei]
			if u == top.p {
				continue
			}
			parent[u] = top.v
			depth[u] = depth[top.v] + 1
			tin[u] = timer
			timer++
			stack = append(stack, Frame{v: u, p: top.v, e: head[u]})
		} else {
			tout[top.v] = timer
			timer++
			stack = stack[:len(stack)-1]
		}
	}

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

	var sb strings.Builder
	sb.Grow(m * 4)

	tmp := make([]int, 0)

	for i := 0; i < m; i++ {
		k := fs.NextInt()
		if cap(tmp) < k {
			tmp = make([]int, 0, k)
		}
		tmp = tmp[:0]

		x := 1
		for j := 0; j < k; j++ {
			v := fs.NextInt()
			if v != 1 {
				v = parent[v]
			}
			tmp = append(tmp, v)
			if depth[v] > depth[x] {
				x = v
			}
		}

		ok := true
		for _, v := range tmp {
			if !isAncestor(v, x) {
				ok = false
				break
			}
		}

		if ok {
			sb.WriteString("YES\n")
		} else {
			sb.WriteString("NO\n")
		}
	}

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	w.WriteString(sb.String())
	w.Flush()
}