#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

struct Node {
    vector<int> childIndices;
    int parent = -1;
    long long value = -1;
    int level = 0;
    int index;
};

vector<Node *> nodes;

void fillLevels(int node, int level) {
    nodes[node]->level = level;
    for (auto i = 0; i < nodes[node]->childIndices.size(); i++) {
        auto child = nodes[nodes[node]->childIndices[i]];
        if (child->value == -1) {
            fillLevels(nodes[node]->childIndices[i], level + 1);
        } else {
            fillLevels(nodes[node]->childIndices[i], 0);
        }
    }
}

void place(unsigned long long value, Node *node) {
    node->value = value;
    auto currentNode = node;
    do {
        currentNode = nodes[currentNode->parent];
        if (currentNode->value == -1) {
            currentNode->value = value;
        }
    } while (currentNode->parent != -1);
}

int main() {
    int n, k;
    cin >> n >> k;

    vector<int> skills;
    for (auto i = 0; i < k; i++) {
        int p;
        cin >> p;
        skills.push_back(p);
    }

    auto root = new Node;
    root->index = 0;
    nodes.push_back(root);

    sort(skills.begin(), skills.end(), greater<int>());

    for (auto i = 1; i < n; i++) {
        auto node = new Node;
        node->index = i;
        cin >> node->parent;
        nodes[node->parent]->childIndices.push_back(i);
        nodes.push_back(node);
    }

    fillLevels(0, 0);

    for (auto i = 0; i < skills.size(); i++) {
        fillLevels(0, 0);
        auto sortedNodes = nodes;
        sort(sortedNodes.begin(), sortedNodes.end(), [](Node *a, Node *b) {
            return a->level > b->level;
        });
        auto skill = skills[i];
        auto node = sortedNodes[0];
        place(skill, node);
    }

    unsigned long long sum = 0;
    // Get sum, but skip root
    for (auto i = 1; i < nodes.size(); i++) {
        sum += nodes[i]->value;
    }

    cout << sum << endl;

    return 0;
}