#include <bits/stdc++.h>
const int N = 20;

void charming() {
  int n; std::cin >> n;
  std::vector<std::array<int, N> > fa(n);
  std::vector<std::vector<int> > G(n);
  for (int i = 1; i < n; ++i) {
    std::cin >> fa[i][0], --fa[i][0];
    G[fa[i][0]].emplace_back(i);
  }

  std::vector<int> dep(n);
  std::function<void(int, int)> DFS = [&](int f, int u) {
    fa[u][0] = f;
    for (int i = 1; i < N; ++i) {
      if (fa[u][i - 1] == -1) fa[u][i] = fa[u][i - 1];
      else fa[u][i] = fa[fa[u][i - 1]][i - 1];
    }

    for (int v : G[u]) {
      if (v == f) continue;
      else dep[v] = dep[u] + 1, DFS(u, v);
    }
  };
  DFS(-1, 0);

  std::function<int(int, int)> jump = [&](int x, int d) {
    assert(d <= dep[x]);
    for (int i = N - 1; i >= 0; --i) {
      if (d >> i & 1) x = fa[x][i];
    }
    return x;
  };

  std::function<int(int, int)> getLca = [&](int u, int v) {
    if (dep[u] != dep[v]) {
      if (dep[u] < dep[v]) std::swap(u, v);
      u = jump(u, dep[u] - dep[v]);
    }
    if (u == v) return u;
    for (int i = N - 1; i >= 0; --i) {
      if (fa[u][i] != fa[v][i]) {
        u = fa[u][i];
        v = fa[v][i];
      }
    }
    return fa[u][0];
  };

  
  int q; std::cin >> q;
  std::vector<int> vis(n), du(n);
  std::vector<std::vector<int> > nG(n);

  for (int i = 0, m; i < q; ++i) {
    std::cin >> m;

    bool ok = true;
    std::vector<int> vec(m);
    for (int j = 0; j < m; ++j) {
      std::cin >> vec[j], --vec[j];
      if (j && dep[vec[j]] < dep[vec[j - 1]]) ok = false;
    }
    if (!ok) std::cout << "No\n";
    else {
      int now = 0;
      std::vector<int> used;
      while (now < m) {
        int nxt = now;
        while (nxt < m && dep[vec[nxt]] == dep[vec[now]]) ++nxt;

//        std::cout << now << ' ' << nxt << std::endl;

        for (int j = now + 1, u, v; j < nxt; ++j) {
          u = vec[j - 1], v = vec[j];
          int lca = getLca(u, v);
          int fu = jump(u, dep[u] - dep[lca] - 1);
          int fv = jump(v, dep[v] - dep[lca] - 1);

//          std::cout << u << ' ' << v << ' ' << lca << std::endl;
//          std::cout << u << ' ' << fu << std::endl;
//          std::cout << v << ' ' << fv << std::endl;
          
          if (!vis[fu]) vis[fu] = 1, used.emplace_back(fu);
          if (!vis[fv]) vis[fv] = 1, used.emplace_back(fv);
          nG[fu].emplace_back(fv);
        }
        now = nxt;

//        std::cout << "Finished." << std::endl;
      }
      
      for (int u : used) {
      	for (int v : nG[u]) ++du[v];
      }
      
      std::vector<int> que;
      int head = 0, tail = 0;
      for (int u : used) if (!du[u]) que.emplace_back(u), ++tail;
      while (head < tail) {
      	int u = que[head++];
      	vis[u] = 0;
      	for (int v : nG[u]) {
      		--du[v];
      		if (!du[v]) que.emplace_back(v), ++tail;
      	}
      }
      for (int u : used) {
      	nG[u].clear();
      	if (vis[u] || du[u]) ok = false, vis[u] = du[u] = 0;
      }
			used.clear();
			
      if (!ok) std::cout << "No\n";
      else std::cout << "Yes\n";
    }
  }
}

signed main() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(NULL);
  std::cout.tie(NULL);
  charming();
  return 0;
}


/*
12
1 1 2 3 4 5 6 6 6 7 8
1
5
2 3 6 8 11
*/