#include <bits/stdc++.h>

#define pb push_back
#define fi first
#define se second

typedef long long ll;
// #define int ll

using namespace std;

const int N = 1e5 + 100;
const int K = 20;
vector<int> g[N];
int pr[N][K];
int dep[N];
void dfs(int v, int p, int d = 0) {
    dep[v] = d;
    pr[v][0] = p;
    for (int i : g[v])
        if (i != p)
            dfs(i, v, d + 1);
}

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

unordered_set<int> alrV;
unordered_map<int, int> down;
unordered_map<int, int> extradown;
bool dfs_check(int v) {
    if (alrV.count(v))
        return true;
    alrV.insert(v);
    if (down[v] + extradown[v] + 1 < int(g[v].size()))
        return false;
    for (int i : g[v])
        if (i != pr[v][0])
            if (!dfs_check(i))
                return false;
    return true;
}

struct HASH {
    auto operator()(pair<int, int> p) const {
        return _Hash_impl::hash(p);
    }
};

bool ask(vector<int> qur) {
    down.clear();
    extradown.clear();
    alrV.clear();
    unordered_set<pair<int, int>, HASH> alr;
    int s = qur[0];
    for (int i = 1; i < int(qur.size()); i++) {
        int v = qur[i];
        if (v == 1)
            return false;
        if (g[s].size() > 1) {//算上父亲的大小了，连的是双向边。这里判叶子，只有叶子才可能是回溯的情况
            if (pr[v][0] != s)
                return false;
            if (alr.count({s, v}))
                return false;
            alr.insert({s, v});
            down[s]++;
            s = v;
        } else {
            for (int i = K - 1; i >= 0; i--)
                if (dep[pr[s][i]] >= dep[v])
                    s = pr[s][i];
            int sup = pr[s][0];
            extradown[sup]++;
            if (pr[v][0] != sup)
                return false;
            alr.insert({sup, s});
            if (alr.count({sup, v}))
                return false;
            alr.insert({sup, v});
            s = v;
        }
    }
    s = qur.back();
    //对于还没有可能还没有遍历完的点都在最后一个点的一条链上，无法判断是不是遍历满子树
    //我们只需要check过程中曾经作为顶点的点，也就是那次dfs实际上是从u从到v

    //核心：如果真的是dfs序列，那么对于alrV的点一定是都会遍历到的并且记录次数的，只有链上的是无法确定的
    for (int i = 0; i - 2 < int(qur.size()); i++) {
        alrV.insert(s);
        s = pr[s][0];
    }
    //    for (auto pa : down)
    //        cout<<pa.fi<<" "<<pa.se+extradown[pa.fi]<<"\n";
    for (auto [v, x] : down)
        if (!dfs_check(v))
            return false;
    return true;
}
void solve() {
    int m;
    cin >> m;
    vector<int> v(m);
    for (int& i : v)
        cin >> i;
    if (ask(v))
        cout << "Yes\n";
    else
        cout << "No\n";
}
main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int n, q;
    cin >> n >> q;
    for (int i = 1; i < n; i++) {
        int x, y;
        cin >> x >> y;
        g[x].pb(y);
        g[y].pb(x);
    }
    dfs(1, 1);
    for (int i = 0; i + 1 < K; i++)
        for (int v = 1; v <= n; v++)
            pr[v][i + 1] = pr[pr[v][i]][i];
    while (q--)
        solve();
}