#include <bits/stdc++.h>

using i64 = long long;

std::mt19937 rnd(std::random_device{}());

struct Node {
    Node *l{}, *r{};
    int s = 0;
    i64 v = 0;
    std::pair<i64, i64> t{0, 0};
    decltype(rnd()) w{rnd()};
};

void pull(Node *u) {
    u->s = 1 + (u->l ? u->l->s : 0) + (u->r ? u->r->s : 0);
}
void apply(Node *u, std::pair<i64, i64> x) {
    if (!u) {
        return;
    }
    u->v += (u->l ? u->l->s : 0) * x.first + x.second;
    u->t = {u->t.first + x.first, u->t.second + x.second};
}
void push(Node *u) {
    apply(u->l, u->t);
    auto t = u->t;
    t.second += t.first * (1 + (u->l ? u->l->s : 0));
    apply(u->r, t);
    u->t = {0, 0};
}

std::pair<Node *, Node *> split(Node *u, Node *v) {
    if (!u) {
        return {u, u};
    }
    push(u);
    if (u->v > v->v) {
        auto [l, r] = split(u->r, v);
        u->r = l;
        pull(u);
        return {u, r};
    } else {
        auto [l, r] = split(u->l, v);
        u->l = r;
        pull(u);
        return {l, u};
    }
}

void insert(Node *&u, Node *v) {
    if (!u) {
        u = v;
        return;
    }
    if (v->w < u->w) {
        std::tie(v->l, v->r) = split(u, v);
        pull(v);
        u = v;
        return;
    }
    push(u);
    if (u->v > v->v) {
        insert(u->r, v);
    } else {
        insert(u->l, v);
    }
    pull(u);
}

void dfs(Node *&u, Node *v) {
    if (!v) {
        return;
    }
    push(v);
    dfs(u, v->l);
    dfs(u, v->r);
    v->l = v->r = nullptr;
    pull(v);
    insert(u, v);
}

void merge(Node *&u, Node *v) {
    if (!u || (v && u->s < v->s)) {
        std::swap(u, v);
    }
    dfs(u, v);
}

i64 get(Node *u, int &k) {
    if (!u || !k) {
        return 0;
    }
    push(u);
    i64 res = get(u->l, k);
    if (k > 0) {
        res += u->v;
        --k;
    }
    res += get(u->r, k);
    return res;
}

int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);

    int n, k;
    std::cin >> n >> k;

    std::vector<std::vector<std::pair<int, int>>> adj(n);
    for (int i = 0; i < n - 1; ++i) {
        int u, v, w;
        std::cin >> u >> v >> w;
        --u, --v;
        adj[u].emplace_back(v, w);
        adj[v].emplace_back(u, w);
    }

    auto dfs = [&](auto self, int u, int fa) -> Node * {
        Node *f{};
        for (auto [v, w] : adj[u]) {
            if (v == fa) {
                continue;
            }
            auto g = self(self, v, u);
            apply(g, {-w * 2, 1ll * w * (k - 1)});
            merge(f, g);
        }
        insert(f, new Node{});
        return f;
    };
    auto f = dfs(dfs, 0, -1);
    std::cout << get(f, k) << "\n";

    return 0;
}