#include<bits/stdc++.h>
using namespace std;

typedef double dbl;
typedef long double ld;
typedef long long ll;

const int MAXN=3e5;
const ll INF=1e18;

inline int Read()
{
    int res;char c;
    while(1) {c=getchar();if('0'<=c && c<='9') {res=c-'0';break;}}
    while(1) {c=getchar();if('0'<=c && c<='9') res=res*10+c-'0';else break;}
    return res;
}

int n,K;
struct DE {int nxt,val;};vector<DE> node[MAXN+5];

void DelFa(int now,int fa)
{
    for(vector<DE>::iterator i=node[now].begin();i!=node[now].end();++i)
        if((*i).nxt==fa) {node[now].erase(i);break;}
    for(int i=0;i<node[now].size();i++) DelFa(node[now][i].nxt,now);
}

struct msg {ll f;int g;}dp[MAXN+5][2];//是否有从根向上延伸的链
inline msg Max(msg a,msg b)
{
    if(a.f>b.f) return a;
    if(a.f<b.f) return b;
    if(a.g<b.g) return a;
    return b;
}
inline msg Add(msg a,msg b) {return msg{a.f+b.f,a.g+b.g};}
inline msg Sub(msg a,msg b) {return msg{a.f-b.f,a.g-b.g};}
void Solve(int now,ll v)//每段有个额外代价 v
{
    msg ALL=msg{0,0};
    for(int i=0,rear;i<node[now].size();i++)
    {
        rear=node[now][i].nxt;
        Solve(rear,v),dp[rear][1].f+=node[now][i].val;
        ALL=Add(ALL,dp[rear][0]);
    }
    dp[now][0]=dp[now][1]=ALL;
    msg max1=msg{0,0};
    for(int i=0,rear;i<node[now].size();i++)
    {
        rear=node[now][i].nxt;
        msg now1=Sub(dp[rear][1],dp[rear][0]);
        dp[now][0]=Max(dp[now][0],Add(Add(ALL,Add(max1,now1)),msg{-v,1}));
        max1=Max(max1,now1);
        dp[now][1]=Max(dp[now][1],Add(ALL,max1));
    }
}

int main()
{
    n=Read(),K=Read();
    for(int i=1,a,b,c;i<n;i++)
    {
        a=Read(),b=Read(),c=Read();
        node[a].push_back(DE{b,c});
        node[b].push_back(DE{a,c});
    }
    DelFa(1,0);
    ll L=-3e11,R=3e11;
    for(ll mid;L<=R;)
    {
        mid=L+((R-L)>>1);
        Solve(1,mid);
        if(dp[1][0].g<=K+1) R=mid-1;
        else L=mid+1;
    }
    Solve(1,L);
    printf("%lld\n",dp[1][0].f+dp[1][0].g*L);
    return 0;
}