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

using namespace std;

// Struktúra az élek tárolására
struct Edge {
    int to, time;
};

// Globális változók
const int MAX_N = 10000;
vector<Edge> tree[MAX_N + 1];
int N, K;

// DFS a legnagyobb várakozási idők ellenőrzésére
bool canSelect(int maxWaitTime, int node, int parent, int &selectedCount) {
    int subordinates = 0;

    for (size_t i = 0; i < tree[node].size(); ++i) {
        Edge edge = tree[node][i];
        if (edge.to == parent) continue;

        if (!canSelect(maxWaitTime, edge.to, node, selectedCount)) {
            subordinates += edge.time;
        }
    }

    // Ha az alárendelt várakozási idő meghaladja a maxWaitTime-t, kijelölünk valakit
    if (subordinates > maxWaitTime) {
        ++selectedCount;
        return true; // Ezt a csomópontot kijelöltük
    }

    return false; // Nem szükséges kijelölni
}

// Ellenőrzi, hogy egy adott maxWaitTime mellett ki lehet-e jelölni K személyt
bool isFeasible(int maxWaitTime) {
    int selectedCount = 0;
    canSelect(maxWaitTime, 1, -1, selectedCount);
    return selectedCount <= K;
}

// Bináris keresés a legnagyobb várakozási idő minimalizálására
int findMinMaxWaitTime() {
    int left = 0, right = 0;

    // Megkeressük a jobb oldali határt (összes kommunikációs idő összege)
    for (int i = 1; i <= N; ++i) {
        for (size_t j = 0; j < tree[i].size(); ++j) {
            right += tree[i][j].time;
        }
    }

    int answer = right;

    while (left <= right) {
        int mid = (left + right) / 2;

        if (isFeasible(mid)) {
            answer = mid; // Lehetséges, próbáljuk csökkenteni
            right = mid - 1;
        } else {
            left = mid + 1; // Nem lehetséges, növeljük a maximumot
        }
    }

    return answer;
}

int main() {
    cin >> N >> K;

    // Beolvassuk a kapcsolatokat
    for (int i = 2; i <= N; ++i) {
        int parent, time;
        cin >> parent >> time;
        tree[parent].push_back((Edge){i, time});
        tree[i].push_back((Edge){parent, time});
    }

    // Megkeressük a minimális legnagyobb várakozási időt
    int result = findMinMaxWaitTime();
    cout << result << endl;

    return 0;
}