#include<iostream>
#include<cstring>
#include<vector>
#include<array>
#include<algorithm>
using namespace std;
using LL = long long;
const int maxn = 3e5 + 5;
vector<pair<int, int> > g[maxn];
int in[maxn], seq[maxn], ts;

void dfs(int u, int fa){
    for(auto it = g[u].begin(); it != g[u].end(); it++){
        if (it->first == fa){
            g[u].erase(it);
            break;
        }
    }
    in[u] = ++ts;
    seq[ts] = u;
    for(auto [j, w] : g[u]){
        dfs(j, u);
    }
}

int main(){

#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif

    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);

    int n, k;
    cin >> n >> k;
    for(int i = 0; i < n - 1; i++){
        int a, b, c;
        cin >> a >> b >> c;
        // 取反转化为求最小值
        c = -c;
        g[a].push_back({b, c});
        g[b].push_back({a, c});
    }
    dfs(1, -1);

    // 转化为可以选k+1条链(可以退化为一个点)
    k += 1;

    // 0: 已经终止
    // 1: 当前子树有一条到根的链
    vector<array<pair<LL, LL>, 2> > dp(n + 1);

    // wqs二分要求在结果相同的时候尽量多拿物品
    // 所以等价于选择任意条链使得总和最小

    auto check = [&](LL mid){
        for(int i = ts; i >= 1; i--){
            int u = seq[i];
            
            vector<int> p;
            for(auto [j, w] : g[u]){
                dp[j][1].first += w;
                p.push_back(j);
            }
            sort(p.begin(), p.end(), [&](int a, int b){
                LL d1 = dp[a][1].first - dp[a][0].first;
                LL d2 = dp[b][1].first - dp[b][0].first;
                if (d1 != d2) return d1 < d2;
                LL d3 = dp[a][1].second - dp[a][0].second;
                LL d4 = dp[b][1].second - dp[b][0].second;
                return d3 > d4;
            });
            // 当前点是一条链的LCA
            {
                pair<LL, LL> ans{mid, 1};
                for(int k = 0; k < 2 and k < p.size(); k++){
                    int j = p[k];
                    if (dp[j][1].first < dp[j][0].first or (dp[j][1].first == dp[j][0].first and dp[j][1].second > dp[j][0].second)){
                        ans.first += dp[j][1].first;
                        ans.second += dp[j][1].second;
                    }
                    else{
                        ans.first += dp[j][0].first;
                        ans.second += dp[j][0].second;
                    }
                }
                for(int k = 2; k < p.size(); k++){
                    int j = p[k];
                    ans.first += dp[j][0].first;
                    ans.second += dp[j][0].second;
                }
                dp[u][0] = ans;
            }
            // 什么都不选
            {
                pair<LL, LL> ans{0, 0};
                for(int k = 0; k < p.size(); k++){
                    int j = p[k];
                    ans.first += dp[j][0].first;
                    ans.second += dp[j][0].second;
                }
                if (ans.first < dp[u][0].first or (ans.first == dp[u][0].first and ans.second > dp[u][0].second)){
                    dp[u][0] = ans;
                }
            }
            {
                pair<LL, LL> ans{0, 0};
                for(int k = 0; k < 1 and k < p.size(); k++){
                    int j = p[k];
                    if (dp[j][1].first < dp[j][0].first or (dp[j][1].first == dp[j][0].first and dp[j][1].second > dp[j][0].second)){
                        ans.first += dp[j][1].first;
                        ans.second += dp[j][1].second;
                    }
                    else{
                        ans.first += dp[j][0].first;
                        ans.second += dp[j][0].second;
                    }
                }
                for(int k = 1; k < p.size(); k++){
                    int j = p[k];
                    ans.first += dp[j][0].first;
                    ans.second += dp[j][0].second;
                }
                dp[u][1] = ans;
            }
        }
        return dp[1][0];
    };

    LL l = -1e12, r = 1e12;
    while(l < r){
        LL mid = l + (r - l + 1) / 2;
        auto [sum, cnt] = check(mid);
        if (cnt >= k) l = mid;
        else r = mid - 1;
    }
    auto [sum, cnt] = check(r);
    cout << -(sum - 1LL * k * r) << '\n';

}