#include <stack>
#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 100005, M = 1000005, B_MODUI = 100;
vector < int > son[N];
int fa[N], hson[N], sz[N], dep[N], dfncnt, invdfn[N], st[2 * N][18], stcnt, _log2[2 * N], start[N];
void dfs(int u) {
    dfncnt++;
    invdfn[dfncnt] = u;
    dep[u] = dep[fa[u]] + 1;
    sz[u] = 1;
    stcnt++;
    st[stcnt][0] = dep[u];
    start[u] = stcnt;
    for (int v : son[u]) {
        dfs(v);
        sz[u] += sz[v];
        if (sz[v] > sz[hson[u]]) {
            hson[u] = v;
        }
        stcnt++;
        st[stcnt][0] = dep[u];
    }
}
int dep_LCA(int u, int v) {
    u = start[u];
    v = start[v];
    if (u > v) {
        u ^= v ^= u ^= v;
    }
    int q = _log2[v - u + 1];
    return min(st[u][q], st[v - (1 << q) + 1][q]);
}
struct Query {
    int l, r, x, id;
    Query(int l_, int r_, int x_, int id_) {
        l = l_;
        r = r_;
        x = x_;
        id = id_;
    }
};
bool operator < (const Query & a, const Query & b) {
    return a.r > b.r;
}
bool recording;
int big[350], small[N];
struct Operation1 {
    int x, w;
    Operation1(int x_, int w_) {
        x = x_;
        w = w_;
    }
    void undo();
};
stack < Operation1 > stk1;
void add(int x, int w) {
    if (recording) {
        stk1.push(Operation1(x, w));
    }
    big[x / 350] += w;
    small[x] += w;
}
void Operation1::undo() {
    add(x, -w);
}
void add(int l, int r, int w) {
    add(l, w);
    add(r + 1, -w);
}
int query(int x) {
    int ans = 0;
    for (int i = 0; i < x / 350; i++) {
        ans += big[i];
    }
    for (int i = x / 350 * 350; i <= x; i++) {
        ans += small[i];
    }
    return ans;
}
vector < Query > que[N / B_MODUI + 5];
int ans[M];
vector < int > layer[N];
struct Node {
    int prv, nxt;
} node[N];
struct Operation2 {
    int a, b, c;
    Operation2(int x, int y, int z) {
        a = x;
        b = y;
        c = z;
    }
    void undo() {
        node[a].nxt = b;
        node[c].prv = b;
    }
};
stack < Operation2 > stk2;
void remove(int u) {
    if (recording) {
        stk2.push(Operation2(node[u].prv, u, node[u].nxt));
    }
    node[node[u].prv].nxt = node[u].nxt;
    node[node[u].nxt].prv = node[u].prv;
}
void link(int u, int v, int w) {
    if (u == 0 || v == 0) {
        return;
    }
    int d = dep_LCA(u, v);
    add(dep[u] - d, dep[u] - 1, w);
}
void del(int v) {
    add(1, dep[v] - 1, -1);
    remove(v);
    int u = node[v].prv;
    int w = node[v].nxt;
    link(u, v, +1);
    link(v, w, +1);
    link(u, w, -1);
}
void build(const vector < int > & vec) {
    if (vec.empty()) {
        return;
    }
    for (int i = 1; i < (int)vec.size(); i++) {
        link(vec[i - 1], vec[i], -1);
        node[vec[i]].prv = vec[i - 1];
        node[vec[i - 1]].nxt = vec[i];
    }
    node[vec.front()].prv = node[vec.back()].nxt = 0;
}
void undo_all() {
    while (!stk1.empty()) {
        stk1.top().undo();
        stk1.pop();
    }
    while (!stk2.empty()) {
        stk2.top().undo();
        stk2.pop();
    }
}
char input[32 * 1024 * 1024];
int read() {
    static char *p = input;
    int x = 0;
    while (*p < 48) {
        p++;
    }
    while (*p >= 48) {
        x = x * 10 + *p - 48;
        p++;
    }
    return x;
}
char output[7 * M], *output_p;
void write_char(char c) {
    *output_p = c;
    output_p++;
}
void write(int x) {
    do {
        write_char(x % 10 + 48);
        x /= 10;
    } while (x != 0);
    write_char(10);
}
int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    fread(input, 1, sizeof(input), stdin);
    int n, m;
    n = read();
    m = read();
    int root = 0;
    for (int u = 1; u <= n; u++) {
        fa[u] = read();
        if (fa[u] == 0) {
            root = u;
        } else {
            son[fa[u]].push_back(u);
        }
    }
    dfs(root);
    for (int i = 2; i <= stcnt; i++) {
        _log2[i] = _log2[i / 2] + 1;
    }
    for (int j = 1; j < 18; j++) {
        for (int i = 1; i <= stcnt - (1 << j) + 1; i++) {
            st[i][j] = min(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
        }
    }
    for (int l, r, x, i = 1; i <= m; i++) {
        l = read();
        r = read();
        x = read();
        que[(l - 1) / B_MODUI].push_back(Query(l, r, x, i));
    }
    for (int i = 0; i <= n / B_MODUI; i++) {
        for (int j = 1; j <= n; j++) {
            layer[j].clear();
        }
        memset(small, 0, sizeof(small));
        memset(big, 0, sizeof(big));
        int l = i * B_MODUI + 1, r = n;
        for (int j = 1; j <= n; j++) {
            int u = invdfn[j];
            if (l <= u && u <= r) {
                add(1, dep[u] - 1, 1);
                layer[dep[u]].push_back(u);
            }
        }
        for (int j = 1; j <= n; j++) {
            build(layer[j]);
        }
        sort(que[i].begin(), que[i].end());
        for (Query q : que[i]) {
            while (r > q.r) {
                del(r);
                r--;
            }
            recording = true;
            for (int j = i * B_MODUI + 1; j < q.l; j++) {
                del(j);
            }
            recording = false;
            ans[q.id] = query(q.x);
            undo_all();
        }
    }
    output_p = output;
    for (int i = 1; i <= m; i++) {
        write(ans[i]);
    }
    fwrite(output, 1, output_p - output, stdout);
    return 0;
}