#include <bits/stdc++.h>

using namespace std;

const int N = 3e5 + 5;
const int M = N << 1;
const int F = 32;

int n, m, q;
int a[N];

vector<int> E[N];
int fat[N][F], dep[N];
void dfs(int u, int fa)
{
    fat[u][0] = fa;
    dep[u] = dep[fa] + 1;
    for (int i = 1; i < F; i++)
        fat[u][i] = fat[fat[u][i - 1]][i - 1];
    for (int v : E[u])
    {
        if (v == fa)
            continue;
        dfs(v, u);
    }
}

inline int LCA(int x, int y, int &u, int &v)
{
    if (dep[x] > dep[y])
        swap(x, y);
    for (int i = F - 1; i >= 0; i--)
        if (dep[x] < dep[fat[y][i]])
            y = fat[y][i];
    if (x == fat[y][0])
    {
        u = x, v = y;
        return x;
    }
    for (int i = F - 1; i >= 0; i--)
    {
        if (fat[x][i] != fat[y][i])
        {
            x = fat[x][i];
            y = fat[y][i];
        }
    }
    u = x, v = y;
    return fat[x][0];
}

int deg[N];
int head[N], nxt[M], to[M], tot;
inline void addedge(int u, int v)
{
    ++tot;
    nxt[tot] = head[u];
    to[tot] = v;
    head[u] = tot;
}

bool vis[N];

int main()
{
    scanf("%d", &n);
    for (int i = 2, j; i <= n; i++)
    {
        scanf("%d", &j);
        E[i].push_back(j);
        E[j].push_back(i);
    }
    dfs(1, 0);
    scanf("%d", &q);
    while (q--)
    {
        scanf("%d", &m);
        for (int u = 1; u <= n; u++)
        {
            vis[u] = false;
        }
        bool flag1 = true;
        for (int i = 1; i <= m; i++)
        {
            scanf("%d", &a[i]);
            if (vis[a[i]])
            {
                flag1 = false;
            }
            vis[a[i]] = true;
        }
        if (!flag1)
        {
            puts("No");
            continue;
        }
        bool flag2 = true;
        for (int i = 1; i < m; i++)
        {
            if (dep[a[i]] > dep[a[i + 1]])
            {
                flag2 = false;
                break;
            }
        }
        if (!flag2)
        {
            puts("No");
            continue;
        }
        vector<int> P;
        for (int i = 1; i < m; i++)
        {
            int u, v;
            int p = LCA(a[i], a[i + 1], u, v);
            addedge(u, v);
            ++deg[v];
            P.push_back(u);
            P.push_back(v);
        }
        sort(P.begin(), P.end());
        P.erase(unique(P.begin(), P.end()), P.end());
        queue<int> Q;
        for (int u : P)
        {
            if (!deg[u])
            {
                Q.push(u);
            }
        }
        int cnt = 0;
        while (!Q.empty())
        {
            int u = Q.front();
            Q.pop();
            cnt++;
            for (int i = head[u]; i; i = nxt[i])
            {
                int v = to[i];
                if (!--deg[v])
                {
                    Q.push(v);
                }
            }
        }
        puts(cnt == P.size() ? "Yes" : "No");
        for (int u : P)
        {
            deg[u] = 0;
            head[u] = 0;
        }
        tot = 0;
    }
    return 0;
}