#include <bits/stdc++.h>
// #include <ext/pb_ds/hash_policy.hpp>
// #include <ext/pb_ds/assoc_container.hpp>

// #pragma GCC optimize(1)
// #pragma GCC optimize(2)
// #pragma GCC optimize(3,"Ofast","inline")

#define INF 0x3f3f3f3f
#define INFLL 0x3f3f3f3f3f3f3f3f

#define lowbit(x)   ((x) & -(x))
#define all(x)      x.begin(), x.end()
#define set_all(x, y)   memset(x, y, sizeof (x))
// #define endl    '\n'
// #define int long long
#define ff  first
#define ss  second
#define pb   push_back

#define typet typename T
#define typeu typename U
#define types typename... Ts
#define tempt template <typet>
#define tempu template <typeu>
#define temps template <types>
#define tandu template <typet, typeu>

#ifdef LOCAL
#include "debug.h"
#else
#define debug(...) do {} while (false)
#endif

using namespace std;
// using namespace __gnu_pbds;

using ULL = unsigned long long;
using LL = long long;
using PII = pair<int, int>;
using PLL = pair<LL, LL>;
using PIB = pair<int, bool>;
using PDD = pair<double, double>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<LL>;
using vvl = vector<vl>;
using vpi = vector<PII>;
// typedef __int128_t i128;

struct custom_hash {
  static uint64_t splitmix64(uint64_t x) {
    x ^= x << 13;
    x ^= x >> 7;
    x ^= x << 17;
    return x;
  }
  size_t operator () (uint64_t x) const {
    static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(x + FIXED_RANDOM);
  }
};

const int N = 300010,  M = 2 * N, K = 31, Mod = 1e9 + 7;
const double pi = acos(-1), eps = 1e-7;
const ULL P = 13331;
struct node {
    int l, r;
    int val;
}tr[N << 2];

void pushup(int u) {
    tr[u].val = min(tr[u << 1].val, tr[u << 1 | 1].val);
}

void build(int u, int l, int r) {
    if (l == r) {
        tr[u] = {l, r, INF};
        return;
    }
    tr[u] = {l, r, INF};
    int mid = l + r >> 1;
    build(u << 1, l, mid);
    build(u << 1 | 1, mid + 1, r);
    pushup(u);
}

int query(int u, int l, int r) {
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].val;
    int mid = tr[u].l + tr[u].r >> 1;
    int res = INF;
    if (l <= mid) res = min(res, query(u << 1, l, r));
    if (r > mid) res = min(res, query(u << 1 | 1, l, r));
    return res;
}

void modify(int u, int x, int d) {
    if (tr[u].l == tr[u].r) {
        tr[u].val = d;
    } else {
        int mid = tr[u].l + tr[u].r >> 1;
        if (x <= mid) modify(u << 1, x, d);
        else modify(u << 1 | 1, x, d);
        pushup(u);
    }
}

void solut(int I) {
    int n;
    cin >> n;
    vector<vector<int>> g(n + 1);
    for (int i = 2; i <= n; i ++) {
        int x;
        cin >> x;
        g[x].push_back(i);
    }
    vector<int> sz(n + 1);
    vector<int> d(n + 1);
    vector<int> dfn(n + 1);
    int tot = 0;
    vector<vector<int>> fa(n + 1, vector<int>(20));
    auto dfs = [&](auto&& self, int u, int f) -> void{
        dfn[u] = ++ tot;
        sz[u] = 1;
        fa[u][0] = f;
        for (int i = 1; i < 20; i ++) {
            fa[u][i] = fa[fa[u][i - 1]][i - 1];
        }
        for (auto v: g[u]) {
            if (v == f) continue;
            d[v] = d[u] + 1;
            self(self, v, u);
            sz[u] += sz[v];
        }
    };
    d[1] = 1;
    dfs(dfs, 1, 1);
    auto lca = [&](int u, int v) -> PII {
        if (d[u] < d[v]) {
            assert(false);
            swap(u, v);
        }
        for (int i = 19; i >= 0; i --) {
            if (d[fa[u][i]] >= d[v]) u = fa[u][i];
        }
        if (u == v) return {u, -1};
        for (int i = 19; i >= 0; i --) {
            if (fa[u][i] != fa[v][i]) {
                u = fa[u][i];
                v = fa[v][i];
            }
        }
        return {u, v};
    };
    build(1, 1, n);

    int q;
    cin >> q;
    vector<vector<int>> e(n + 1);
    vector<int> din(n + 1);
    while (q --) {
        bool check = true;
        int m;
        cin >> m;
        vector<int> b(m + 1);
        vector<int> node;
        for (int i = 1; i <= m; i ++) {
            cin >> b[i];
            node.push_back(b[i]);
            if (i > 1) {
                e[b[i - 1]].push_back(b[i]);
                din[b[i]] ++;
            }
        }
        int prev = 0;
        for (int i = 1; i <= m; i ++) {
            int j = i + 1;
            if (d[b[i]] < prev) {
                e[b[i]].push_back(b[i - 1]);
                din[b[i - 1]] ++;
            }
            while (j <= m && d[b[j]] == d[b[i]]) {
                auto [x, y] = lca(b[j - 1], b[j]);
                node.push_back(x);
                node.push_back(y);
                e[x].push_back(y);
                din[y] ++;
                j ++;
            }
            prev = d[b[i]];
            i = j - 1;
        }
        sort(all(node));
        node.erase(unique(all(node)), node.end());
        vector<int> que;
        // debug(din);
        for (auto x: node) {
            if (din[x] == 0) que.push_back(x);
        }
        // debug(que);
        for (int i = 0, j = que.size(); i < j; i ++) {
            int u = que[i];
            for (int v: e[u]) {
                din[v] --;
                // debug(v, u);
                if (din[v] == 0) {
                    que.push_back(v);
                    j ++;
                }
            }
        }
        for (auto x: node) {
            if (din[x]) check = false;
        }
        
        for (auto x: node) {
            e[x].clear();
            din[x] = 0;
        }
        if (check) cout << "Yes" << '\n';
        else cout << "No" <<'\n';
    }
}

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

signed main() {
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    int T;
    T = 1;
    // cin >> T;
    for (int _ = 1; _ <= T; _ ++) {
        solut(_);
    }
}