import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.StringTokenizer;

public class Solution implements Runnable {
    private BufferedReader br;
    private StringTokenizer tok;
    private PrintWriter out;

    public static final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
    public static final int MAGIC = 21;

    ArrayList<Integer>[] g;

    int[] p;
    int[] h;
    int[] id;
    int[][] dp;

    void initGraph(int n) {
        g = new ArrayList[n];
        for (int i = 0; i < n; ++i) {
            g[i] = new ArrayList<Integer>();
        }
    }

    void dfs(int v, int pv, int height, int par) {
        p[v] = pv;
        h[v] = height;
        id[v] = par;
        for (int i = 0; i < g[v].size(); ++i) {
            int to = g[v].get(i);
            dfs(to, v, height + 1, par);
        }
    }

    void prepare(int n) {
        dp = new int[n][MAGIC];
        for (int j = 0; j < MAGIC; ++j)
            for (int i = 0; i < n; ++i)
                if (j == 0) {
                    dp[i][j] = p[j];
                } else {
                    dp[i][j] = dp[dp[i][j - 1]][j - 1];
                }
    }

    int getAncestor(int v, int dg) {
        int u = v;
        int dif = dg;
        for (int i = 17; i >= 0; --i)
            if (dif >= (1 << i)) {
                dif -= 1 << i;
                u = dp[u][i];
            }
        if (h[v] - h[u] != dg)
            return - 1;
        return u;
    }

    void solve() throws IOException {
        int n = nextInt();
        initGraph(n);
        ArrayList<Integer> roots = new ArrayList<Integer>();
        for (int i = 0; i < n; ++i) {
            int pv = nextInt() - 1;
            if (pv != -1) {
                g[pv].add(i);
            } else {
                roots.add(i);
            }
        }
        p = new int[n];
        h = new int[n];
        id = new int[n];
        for (int i = 0; i < roots.size(); ++i) {
            dfs(roots.get(i), roots.get(i), 0, i);
        }
        prepare(n);
        HashMap<Integer, Integer>[] cnt = new HashMap[MAGIC];
        for (int i = 0; i < MAGIC; ++i) {
            cnt[i] = new HashMap<Integer, Integer>();
        }
        for (int i = 0; i < n; ++i)
            if (cnt[h[i]].containsKey(id[i])) {
                int value = cnt[h[i]].get(id[i]);
                cnt[h[i]].remove(id[i]);
                cnt[h[i]].put(id[i], value + 1);
            } else {
                cnt[h[i]].put(id[i], 1);
            }
        int q = nextInt();
        for (int i = 0; i < q; ++i) {
            int v = nextInt();
            int a = nextInt();
            int u = getAncestor(v - 1, a);
            if (u == -1) {
                out.print("0 ");
            } else {
                out.print((cnt[h[v - 1]].get(id[v - 1]) - 1) + " ");
            }
        }
    }

    public void run() {
        try {
            if (ONLINE_JUDGE) {
                br = new BufferedReader(new InputStreamReader(System.in));
                out = new PrintWriter(System.out);
            } else {
                br = new BufferedReader(new FileReader(new File("input.txt")));
                out = new PrintWriter(new File("output.txt"));
            }
            solve();
            br.close();
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    public static void main(String[] args) {
        new Solution().run();
    }

    String nextToken() throws IOException {
        while (tok == null || !tok.hasMoreTokens())
            tok = new StringTokenizer(br.readLine());
        return tok.nextToken();
    }

    String nextString() throws IOException {
        return nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    BigInteger nextBigInteger() throws IOException {
        return new BigInteger(nextToken());
    }
}