#include <vector>
#include <iostream>
#include <functional>

using namespace std;

struct SegmentTree
{
    constexpr static int N = 1e6 + 5;

#define rson ((k << 1) + 1)
#define lson (k << 1)
#define me (k)
#define mid ((a[me].l + a[me].r) >> 1)

    struct node
    {
        int l, r;
        int sum;
        int lazy;

        node()
        {
            l = r = sum = 0;
            lazy = -1;
        }
    };

    vector<node> a = vector<node>(N * 4);

    void update(int k)
    {
        a[me].sum = a[lson].sum + a[rson].sum;
    }

    void build(int k, int l, int r)
    // 当前在k上,建树
    {
        a[me].l = l;
        a[me].r = r;
        if (l == r)
        {
            a[me].sum = 0;
            return;
        }
        build(lson, a[me].l, mid);
        build(rson, mid + 1, a[me].r);
        update(k);
    }

    void pushdown(int k)
    {
        if (a[me].l == a[me].r)
        {
            a[me].lazy = -1;
            return;
        }
        a[lson].sum = (a[lson].r - a[lson].l + 1) * a[me].lazy;
        a[rson].sum = (a[rson].r - a[rson].l + 1) * a[me].lazy;
        a[lson].lazy = a[me].lazy;
        a[rson].lazy = a[me].lazy;
        a[me].lazy = -1;
    }

    int query(int k, int idx)
    {
        if (a[me].lazy != -1)
            pushdown(k);
        if (a[me].l == idx && a[me].r == idx)
            return a[me].sum;
        if (idx <= mid)
            return query(lson, idx);
        return query(rson, idx);
    }

    void set_segment(int k, int l, int r, int x)
    {
        if (a[k].l == l && a[k].r == r)
        {
            a[k].sum = (r - l + 1) * x;
            a[k].lazy = x;
            return;
        }
        if (a[me].lazy != -1)
            pushdown(k);
        if (r <= mid)
            set_segment(lson, l, r, x);
        else if (l > mid)
            set_segment(rson, l, r, x);
        else
        {
            set_segment(lson, l, mid, x);
            set_segment(rson, mid + 1, r, x);
        }
        update(k);
    }
#undef rson
#undef lson
#undef me
#undef mid
};

void solve()
{
    int n;
    cin >> n;
    int q;
    cin >> q;
    SegmentTree st;
    st.build(1, 1, n);
    vector<vector<int>> tree(n + 1);
    for (int i = 1; i <= n - 1; i++)
    {
        int u, v;
        cin >> u >> v;
        tree[u].emplace_back(v);
        tree[v].emplace_back(u);
    }
    vector<int> dfn(n + 1);
    vector<int> ofn(n + 1);
    vector<int> sz(n + 1);
    vector<int> ffa(n + 1);
    vector<int> depth(n + 1);
    //SegmentTree st;

    int dfncnt = 0;
    function<void(int, int)> dfs = [&](int node, int fa) -> void
    {
        dfncnt++;
        dfn[node] = dfncnt;
        depth[node] = depth[fa] + 1;
        ffa[node] = fa;
        for (const int& child : tree[node])
        {
            if (child == fa) continue;
            dfs(child, node);
        }
        ofn[node] = dfncnt;
        sz[node] = ofn[node] - dfn[node];
    };

    dfs(1, 0);

    function<bool(int, int)> is_in_tree = [&](int node, int fa) -> bool
    {
        return dfn[node] >= dfn[fa] && dfn[node] <= ofn[fa];
    };

    vector<int> stk;
    auto pop_stk = [&]() -> void
    {
        int node = stk.back();
        stk.pop_back();
    };
    auto push_stk = [&](int node) -> void
    {
        stk.push_back(node);
        st.set_segment(1, dfn[node], dfn[node], 1);
    };

    vector<int> k;
    vector<int> tmp;
    while (q--)
    {
        int qq;
        cin >> qq;
        k.resize(qq + 1);
        for (int i = 1; i <= qq; i++)
            cin >> k[i];

        // TODO: clear the SegmentTree
        st.set_segment(1, 1, n, 0);

        tmp.clear();
        int node = k[1];

        stk.clear();
        while (node != 0)
        {
            tmp.push_back(node);
            node = ffa[node];
        }
        reverse(tmp.begin(), tmp.end());
        for (const int& nd : tmp)
            push_stk(nd);

        bool isok = true;

        if (!is_in_tree(k[min(1 + sz[k[1]], qq)], k[1]))
            isok = false;

        for (int i = 2; i <= qq; i++)
        {
            if (!is_in_tree(k[min(i + sz[k[i]], qq)], k[i])) isok = false;
            if (!isok) break;
            int thisfa = ffa[k[i]];
            int nearfa = -1;
            while (!stk.empty() && stk.back() != thisfa)
            {
                nearfa = stk.back();
                pop_stk();
            }
            if (stk.empty()) isok = false;
            if (!isok) break;

            // TODO: ensure it's not visited in SegmentTree
            if (st.query(1, dfn[k[i]]))
                isok = false;
            if (!isok) break;

            push_stk(k[i]);

            if (thisfa != k[i - 1])
            {
                // TODO: ensure the childs of nearfa and itself is visited
                st.set_segment(1, dfn[nearfa], ofn[nearfa], 1);
            }
        }

        if (isok) cout << "Yes\n";
        else cout << "No\n";
    }
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int t = 1;
    //cin >> t;
    while (t--)
        solve();
}

/*
*
6 4
1 2
1 3
2 4
3 5
2 6
3 4 6 3
3 4 6 1
4 2 6 4 3
4 1 4 6 3
*/