/// @author Camillus <3
#include "bits/stdc++.h"

using ll = long long;
using namespace std;

int p[100500];
vector<int> g[100500];
int h[100500];

int sz[100500];
void dfs_sz(int u) {
    sz[u] = 1;
    for (int& v : g[u]) {
        dfs_sz(v);
        sz[u] += sz[v];
    }
}

void dfs_h(int u) {
    if (!g[u].empty()) {
        for (int v : g[u]) {
            h[v] = v;
        }
        h[g[u].front()] = h[u];
    }

    for (int v : g[u]) {
        dfs_h(v);
    }
}

pair<int, int> f[100500];

struct segment_tree {
    segment_tree() = default;

    static constexpr ll NOP = LLONG_MAX;

    struct node {
        ll max = 0;
        ll add = 0;
        ll op = NOP;
    };

    vector<node> tree;
    int n = 0;

    segment_tree(int m) {
        n = 1;
        while (n < m) {
            n *= 2;
        }
        tree.resize(n * 2 - 1);
    }

//    void apply_add(int x, ll v);
//    void apply_op(int x, ll v);

    void push(int x) {
        if (tree[x].add != 0) {
            apply_add(x * 2 + 1, tree[x].add);
            apply_add(x * 2 + 2, tree[x].add);
            tree[x].add = 0;
        }
        if (tree[x].op != NOP) {
            apply_op(x * 2 + 1, tree[x].op);
            apply_op(x * 2 + 2, tree[x].op);
            tree[x].op = NOP;
        }
    }

    void apply_add(int x, ll v) {
        if (tree[x].op != NOP) {
            push(x);
        }
        tree[x].max += v;
        tree[x].add += v;
    }

    void apply_op(int x, ll v) {
        tree[x].max = v;
        tree[x].add = 0;
        if (x < n - 1) {
            tree[x].op = v;
        }
    }

    void pull(int x) {
        tree[x].max = max(tree[x * 2 + 1].max, tree[x * 2 + 2].max);
    }

    void op(int l, int r, ll v, int x = 0, int lx = 0, int rx = -1) {
        if (rx == -1) {
            rx = n;
        }

        if (l <= lx && rx <= r) {
            apply_op(x, v);
            return;
        }

        if (l >= rx || lx >= r) {
            return;
        }

        push(x);

        op(l, r, v, x * 2 + 1, lx, (lx + rx) / 2);
        op(l, r, v, x * 2 + 2, (lx + rx) / 2, rx);

        pull(x);
    }

    void add(int l, int r, ll v, int x = 0, int lx = 0, int rx = -1) {
        if (rx == -1) {
            rx = n;
        }

        if (l <= lx && rx <= r) {
            apply_add(x, v);
            return;
        }

        if (l >= rx || lx >= r) {
            return;
        }

        push(x);

        add(l, r, v, x * 2 + 1, lx, (lx + rx) / 2);
        add(l, r, v, x * 2 + 2, (lx + rx) / 2, rx);

        pull(x);
    }

    ll get(int i, int x = 0, int lx = 0, int rx = -1) {
        if (rx == -1) {
            rx = n;
        }

        if (rx - lx == 1) {
            return tree[x].max;
        }

        push(x);

        if (i < (lx + rx) / 2) {
            return get(i, x * 2 + 1, lx, (lx + rx) / 2);
        } else {
            return get(i, x * 2 + 2, (lx + rx) / 2, rx);
        }
    }

    int lower_bound(ll v, int x = 0, int lx = 0, int rx = -1) {
        if (rx == -1) {
            rx = n;
        }

        if (rx - lx == 1) {
            return lx;
        }

        push(x);

        if (tree[x * 2 + 1].max >= v) {
            return lower_bound(v, x * 2 + 1, lx, (lx + rx) / 2);
        } else {
            return lower_bound(v, x * 2 + 2, (lx + rx) / 2, rx);
        }
    }
};

struct ds {
    vector<int> keys;
    ds() {}

    void add_key(int day) {
        keys.push_back(day);
    }

    int n;
    segment_tree st;

    void build() {
        ranges::sort(keys);
        keys.erase(unique(keys.begin(), keys.end()), keys.end());
        n = (int)keys.size();
        st = segment_tree(n);
    }

    int lower_bound(int key) {
        auto i = ranges::lower_bound(keys, key) - keys.begin();
        return i;
    }

    void add(int l, int r, ll v) {
        st.add(l, r + 1, v);
    }

    void op(int l, int r, ll v) {
        st.op(l, r + 1, v);
    }

    ll get(int i) {
        return st.get(i);
    }
};

ds DS[100500];
void make_ds(int n) {
    for (int u = 1; u <= n; u++) {
        if (h[u] == u) {
            auto dfs = [&r=u](auto &&dfs, int u) -> void {
                if (f[u].first) {
                    DS[r].add_key(f[u].first);
                }
                for (int v : g[u]) {
                    dfs(dfs, v);
                }
            };
            dfs(dfs, u);
            DS[u].build();
        }
    }
}

void dfs(int u) {
    for (int v : g[u]) {
        dfs(v);

        if (v != g[u].front()) {
            for (int i = 0; i < DS[v].n; i++) {
                int L = DS[v].keys[i];
                int R = 2'000'000'000;
                if (i + 1 != DS[v].n) {
                    R = DS[v].keys[i + 1];
                }

                ll D = DS[v].get(i);

                L = DS[h[u]].lower_bound(L);
                R = DS[h[u]].lower_bound(R);

                DS[h[u]].add(L, R - 1, D);
            }
        }
    }

    if (f[u].first != 0) {
        int i = DS[h[u]].lower_bound(f[u].first);
        ll value = DS[h[u]].get(i) + f[u].second;

        if (DS[h[u]].get(DS[h[u]].n - 1) <= value) {
            DS[h[u]].op(i, DS[h[u]].n - 1, value);
        } else {
            int j = DS[h[u]].st.lower_bound(value);
            assert(DS[h[u]].get(j) >= value);
            DS[h[u]].op(i, j - 1, value);
        }
    }
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    h[1] = 1;

    int n, m, k;
    cin >> n >> m >> k;

    for (int u = 2; u <= n; u++) {
        cin >> p[u];
        g[p[u]].push_back(u);
    }

    for (int i = 0; i < m; i++) {
        int u, d, w;
        cin >> u >> d >> w;

        f[u] = {d, w};
    }

    dfs_sz(1);
    dfs_h(1);
    make_ds(n);
    dfs(1);

    cout << DS[1].get(DS[1].n - 1) << '\n';
    return 0;
}