#include <bits/stdc++.h>
template <class T, class binary_op = std::plus<T>>
struct Binary_Indexed_Tree_like {
    int n;
    std::vector<T> tree, tree2;
    binary_op comb;
    T init;
    std::stack<std::pair<std::vector<std::pair<int, T>>, std::vector<std::pair<int, T>>>> st;
    Binary_Indexed_Tree_like(int n, const binary_op &comb = binary_op(), const T &init = T()) : n(n), tree(n, init), tree2(n, init), comb(comb), init(init) {}
    static constexpr int lowbit(int x) { return x & -x; }
    void add(int x, const T &y) {
        std::pair<std::vector<std::pair<int, T>>, std::vector<std::pair<int, T>>> tmp;
        for (int i = x + 1; i <= n; i += lowbit(i))
            tmp.first.emplace_back(i - 1, tree[i - 1]), tree[i - 1] = comb(tree[i - 1], y);
        for (int i = x; i > 0; i -= lowbit(i))
            tmp.second.emplace_back(i - 1, tree2[i - 1]), tree2[i - 1] = comb(tree2[i - 1], y);
        st.push(std::move(tmp));
        return;
    }
    T sum(int l, int r) const {
        T ans(init);
        for (int i = l; i && i + lowbit(i) <= r + 1; i += lowbit(i))
            ans = comb(ans, tree2[i - 1]);
        for (int i = r + 1; i && i - lowbit(i) >= l; i -= lowbit(i))
            ans = comb(ans, tree[i - 1]);
        return ans;
    }
    void undo() {
        for (const auto &i : st.top().first)
            tree[i.first] = i.second;
        for (const auto &i : st.top().second)
            tree2[i.first] = i.second;
        st.pop();
        return;
    }
};
struct tree {
    int n;
    std::vector<std::vector<int>> children;
    std::vector<int> dfn, parent, senior, siz, top, seq, qes;
    int doc;
    tree(int n) : n(n), children(n) {}
    void add_edge(int u, int v) {
        children[u].push_back(v);
        return;
    }
    void dfs(int x) {
        siz[x] = 1;
        senior[x] = -1;
        for (int y : children[x]) {
            parent[y] = x;
            dfs(y);
            siz[x] += siz[y];
            if (!~senior[x] || siz[y] > siz[senior[x]])
                senior[x] = y;
        }
        return;
    }
    void dfs(int x, int t) {
        qes.push_back(x);
        dfn[x] = doc++;
        top[x] = t;
        if (~senior[x])
            dfs(senior[x], t);
        for (int y : children[x])
            if (y != senior[x])
                dfs(y, y);
        seq.push_back(x);
        return;
    }
    bool in(int x, int y) {
        return dfn[y] <= dfn[x] && dfn[x] <= dfn[y] + siz[y] - 1;
    }
    void build() {
        dfn.assign(n, -1);
        parent.assign(n, -1);
        senior.assign(n, -1);
        siz.assign(n, 0);
        top.assign(n, -1);
        doc = 0;
        dfs(0);
        dfs(0, 0);
        return;
    }
};
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    int n, m;
    std::cin >> n >> m;
    tree g(n);
    for (int i = 1; i < n; ++i) {
        int x;
        std::cin >> x;
        --x;
        g.add_edge(x, i);
    }
    g.build();
    std::vector<std::pair<std::vector<int>, std::vector<int>>> s(n);
    std::vector<std::pair<int, int>> c(m);
    for (int i = 0; i < m; ++i)
        std::cin >> c[i].first >> c[i].second, --c[i].first, --c[i].second, s[c[i].first].first.push_back(i), s[c[i].second].second.push_back(i);
    std::vector<int> pa(m);
    std::iota(pa.begin(), pa.end(), 0);
    std::function<int(int)> find_set = [&](int x) -> int {
        if (x == pa[x])
            return x;
        return pa[x] = find_set(pa[x]);
    };
    static constexpr std::pair<int, int> _(std::numeric_limits<int>::max(), -1);
    typedef std::remove_const_t<decltype(_)> __t;
    static constexpr std::pair<__t, __t> __(_, _);
    typedef std::remove_const_t<decltype(__)> ___t;
    auto take = [](const ___t &x, const ___t &y) -> ___t {
        return {std::min(x.first, y.first), x.first.second == y.first.second ? std::min(x.second, y.second) : (x.first == std::min(x.first, y.first) ? std::min(x.second, y.first) : std::min(x.first, y.second))};
    };
    auto add = [](const __t &x, int y) -> __t {
        return {x.first == std::numeric_limits<int>::max() ? x.first : x.first + y, x.second};
    };
    auto choose = [](const ___t &x, int y) -> __t {
        return x.first.second == y ? x.second : x.first;
    };
    long long ans = 0;
    while (std::adjacent_find(pa.begin(), pa.end(), [&](int x, int y) -> bool { return find_set(x) != find_set(y); }) != pa.end()) {
        std::vector<__t> d(m, _);
        ___t p(__);
        for (int i = 0; i < m; ++i)
            p = take(p, {{g.siz[c[i].first] + g.siz[c[i].second], find_set(i)}, _});
        for (int i = 0; i < m; ++i)
            d[find_set(i)] = std::min(d[find_set(i)], add(choose(p, find_set(i)), g.siz[c[i].first] + g.siz[c[i].second]));
        std::vector<std::pair<___t, ___t>> f(n, {__, __});
        for (int i : g.seq) {
            for (int j : s[i].first)
                f[i].first = take(f[i].first, {{g.siz[c[j].second] - g.siz[c[j].first], find_set(j)}, _});
            for (int j : s[i].second)
                f[i].second = take(f[i].second, {{g.siz[c[j].first] - g.siz[c[j].second], find_set(j)}, _});
            for (int j : g.children[i])
                f[i].first = take(f[i].first, f[j].first), f[i].second = take(f[i].second, f[j].second);
            for (int j : s[i].first)
                d[find_set(j)] = std::min(d[find_set(j)], add(choose(f[i].first, find_set(j)), g.siz[c[j].first] + g.siz[c[j].second]));
            for (int j : s[i].second)
                d[find_set(j)] = std::min(d[find_set(j)], add(choose(f[i].second, find_set(j)), g.siz[c[j].first] + g.siz[c[j].second]));
        }
        f.assign(n, {__, __});
        for (int i : g.qes) {
            for (int j : s[i].first)
                f[i].first = take(f[i].first, {{g.siz[c[j].first] + g.siz[c[j].second], find_set(j)}, _});
            for (int j : s[i].second)
                f[i].second = take(f[i].second, {{g.siz[c[j].first] + g.siz[c[j].second], find_set(j)}, _});
            for (int j : g.children[i])
                f[j].first = take(f[j].first, f[i].first), f[j].second = take(f[j].second, f[i].second);
            for (int j : s[i].first)
                d[find_set(j)] = std::min(d[find_set(j)], add(choose(f[i].first, find_set(j)), g.siz[c[j].second] - g.siz[c[j].first]));
            for (int j : s[i].second)
                d[find_set(j)] = std::min(d[find_set(j)], add(choose(f[i].second, find_set(j)), g.siz[c[j].first] - g.siz[c[j].second]));
        }
        Binary_Indexed_Tree_like<___t, decltype(take)> f3(n, take, __);
        std::vector<int> p3(n), l;
        std::reverse_copy(g.qes.begin(), g.qes.end(), std::back_inserter(l));
        for (int i : l) {
            while (f3.st.size() > (~g.senior[i] ? p3[g.senior[i]] : 0))
                f3.undo();
            for (int j : s[i].first)
                f3.add(g.dfn[c[j].second], {{-g.siz[c[j].first] - g.siz[c[j].second], find_set(j)}, _});
            for (int j : g.children[i]) {
                if (j != g.senior[i]) {
                    std::queue<int> q;
                    q.push(j);
                    while (!q.empty()) {
                        int x = q.front();
                        q.pop();
                        for (int y : s[x].first)
                            f3.add(g.dfn[c[y].second], {{-g.siz[c[y].first] - g.siz[c[y].second], find_set(y)}, _});
                        for (int y : g.children[x])
                            q.push(y);
                    }
                }
            }
            p3[i] = f3.st.size();
            for (int j : s[i].first)
                d[find_set(j)] = std::min(d[find_set(j)], add(choose(f3.sum(g.dfn[c[j].second], g.dfn[c[j].second] + g.siz[c[j].second] - 1), find_set(j)), g.siz[c[j].first] + g.siz[c[j].second]));
        }
        for (int i : g.qes) {
            while (f3.st.size() > (~g.parent[i] ? p3[g.parent[i]] : 0))
                f3.undo();
            for (int j : s[i].first)
                f3.add(g.dfn[c[j].second], {{g.siz[c[j].first] - g.siz[c[j].second], find_set(j)}, _});
            p3[i] = f3.st.size();
            for (int j : s[i].first)
                d[find_set(j)] = std::min(d[find_set(j)], add(choose(f3.sum(g.dfn[c[j].second], g.dfn[c[j].second] + g.siz[c[j].second] - 1), find_set(j)), g.siz[c[j].second] - g.siz[c[j].first]));
        }
        for (int i : g.qes) {
            while (f3.st.size() > (~g.parent[i] ? p3[g.parent[i]] : 0))
                f3.undo();
            for (int j : s[i].second)
                f3.add(g.dfn[c[j].first], {{g.siz[c[j].second] - g.siz[c[j].first], find_set(j)}, _});
            p3[i] = f3.st.size();
            for (int j : s[i].second)
                d[find_set(j)] = std::min(d[find_set(j)], add(choose(f3.sum(g.dfn[c[j].first], g.dfn[c[j].first] + g.siz[c[j].first] - 1), find_set(j)), g.siz[c[j].first] - g.siz[c[j].second]));
        }
        auto upward = [&](int x) -> ___t {
            ___t ans(__);
            while (~x) {
                ans = take(ans, f3.sum(g.dfn[g.top[x]], g.dfn[x]));
                x = g.parent[g.top[x]];
            }
            return ans;
        };
        for (int i : g.qes) {
            while (f3.st.size() > (~g.parent[i] ? p3[g.parent[i]] : 0))
                f3.undo();
            for (int j : s[i].first)
                f3.add(g.dfn[c[j].second], {{g.siz[c[j].first] + g.siz[c[j].second], find_set(j)}, _});
            p3[i] = f3.st.size();
            for (int j : s[i].first)
                d[find_set(j)] = std::min(d[find_set(j)], add(choose(upward(c[j].second), find_set(j)), -g.siz[c[j].first] - g.siz[c[j].second]));
        }
        std::vector<std::tuple<int, int, int>> e;
        for (int i = 0; i < m; ++i)
            if (i == find_set(i) && d[i].first < std::numeric_limits<int>::max())
                e.emplace_back(i, d[i].second, d[i].first);
        std::sort(e.begin(), e.end(), [](const std::tuple<int, int, int> &x, const std::tuple<int, int, int> &y) -> bool { return std::get<2>(x) < std::get<2>(y); });
        for (auto [u, v, w] : e)
            if (find_set(u) != find_set(v))
                pa[find_set(u)] = find_set(v), ans += w;
    }
    std::cout << ans << '\n';
    return 0;
}