```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"container/heap"
)

const INF = 1 << 60

type Pair struct {
	node int
	weight int
}

type PQD struct {
	dist int64
	node int
}

type PriorityQueue []*PQD

func (pq PriorityQueue) Len() int { return len(pq) }

func (pq PriorityQueue) Less(i, j int) bool {
	return pq[i].dist < pq[j].dist
}

func (pq PriorityQueue) Swap(i, j int) {
	pq[i], pq[j] = pq[j], pq[i]
}

func (pq *PriorityQueue) Push(x interface{}) {
	item := x.(*PQD)
	*pq = append(*pq, item)
}

func (pq *PriorityQueue) Pop() interface{} {
	old := *pq
	n := len(old)
	item := old[n-1]
	*pq = old[0 : n-1]
	return item
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)

	var n, k int
	fmt.Fscan(in, &n, &k)

	adj := make([][]Pair, n+1)
	for i := 0; i < n-1; i++ {
		var u, v, d int
		fmt.Fscan(in, &u, &v, &d)
		adj[u] = append(adj[u], Pair{v, d})
		adj[v] = append(adj[v], Pair{u, d})
	}

	dijkstra := func(start int) (dist []int64, prev []int) {
		dist = make([]int64, n+1)
		prev = make([]int, n+1)
		for i := range dist {
			dist[i] = INF
			prev[i] = -1
		}
		dist[start] = 0
		pq := make(PriorityQueue, 0)
		heap.Init(&pq)
		heap.Push(&pq, &PQD{0, start})
		for pq.Len() > 0 {
			curr := heap.Pop(&pq).(*PQD)
			if curr.dist > dist[curr.node] {
				continue
			}
			for _, e := range adj[curr.node] {
				if dist[e.node] > dist[curr.node]+int64(e.weight) {
					dist[e.node] = dist[curr.node] + int64(e.weight)
					prev[e.node] = curr.node
					heap.Push(&pq, &PQD{dist[e.node], e.node})
				}
			}
		}
		return
	}

	farthest := func(start int) (maxDist int64, maxNode int) {
		dist, _ := dijkstra(start)
		maxDist = -1
		for i := 1; i <= n; i++ {
			if dist[i] < INF && dist[i] > maxDist {
				maxDist = dist[i]
				maxNode = i
			}
		}
		return
	}

	_, A := farthest(1)
	_, B := farthest(A)

	_, prev := dijkstra(A)
	path := make([]int, 0)
	for cur := B; cur != -1; cur = prev[cur] {
		path = append(path, cur)
	}
	for i, j := 0, len(path)-1; i < j; i, j = i+1, j-1 {
		path[i], path[j] = path[j], path[i]
	}

	mm := len(path)
	dist_prefix := make([]int64, mm)
	dist_prefix[0] = 0
	for i := 1; i < mm; i++ {
		u := path[i-1]
		v := path[i]
		for _, e := range adj[u] {
			if e.node == v {
				dist_prefix[i] = dist_prefix[i-1] + int64(e.weight)
				break
			}
		}
	}

	dist_suffix := make([]int64, mm)
	dist_suffix[mm-1] = 0
	for i := mm - 2; i >= 0; i-- {
		u := path[i+1]
		v := path[i]
		for _, e := range adj[u] {
			if e.node == v {
				dist_suffix[i] = dist_suffix[i+1] + int64(e.weight)
				break
			}
		}
	}

	height := make([]int64, n+1)
	var dfs1 func(int, int)
	dfs1 = func(u, p int) {
		height[u] = 0
		for _, e := range adj[u] {
			v := e.node
			w := e.weight
			if v != p {
				dfs1(v, u)
				height[u] = max(height[u], int64(w)+height[v])
			}
		}
	}
	dfs1(1, -1)

	up_height := make([]int64, n+1)
	up_height[1] = 0
	var dfs2 func(int, int)
	dfs2 = func(u, p int) {
		down_hs := make([]int64, 0)
		childs := make([]int, 0)
		for _, e := range adj[u] {
			v := e.node
			w := e.weight
			if v != p {
				childs = append(childs, v)
				down_hs = append(down_hs, int64(w)+height[v])
			}
		}
		nc := len(down_hs)
		max1, max2 := int64(-1), int64(-1)
		for _, h := range down_hs {
			if h > max1 {
				max2 = max1
				max1 = h
			} else if h > max2 {
				max2 = h
			}
		}
		for j := 0; j < nc; j++ {
			v := childs[j]
			this_down := down_hs[j]
			max_other := max1
			if this_down == max1 {
				max_other = max2
			}
			max_exc := int64(0)
			max_exc = max(max_exc, up_height[u])
			if max_other > -1 {
				max_exc = max(max_exc, max_other)
			}
			var ww int
			for _, e := range adj[u] {
				if e.node == v {
					ww = e.weight
					break
				}
			}
			up_height[v] = int64(ww) + max_exc
		}
		for j := 0; j < nc; j++ {
			dfs2(childs[j], u)
		}
	}
	dfs2(1, -1)

	dirs := make([][]int64, n+1)
	var collect func(int, int)
	collect = func(u, p int) {
		dirs[u] = make([]int64, 0)
		if p != -1 {
			dirs[u] = append(dirs[u], up_height[u])
		}
		for _, e := range adj[u] {
			v := e.node
			w := e.weight
			if v != p {
				dirs[u] = append(dirs[u], int64(w)+height[v])
			}
		}
		for _, e := range adj[u] {
			if e.node != p {
				collect(e.node, u)
			}
		}
	}
	collect(1, -1)

	check := func(D int64) bool {
		possible := true
		for u := 1; u <= n; u++ {
			cnt := 0
			for _, h := range dirs[u] {
				if h > D {
					cnt++
				}
			}
			if cnt >= 3 {
				possible = false
				break
			}
		}
		if !possible {
			return false
		}
		left := -1
		for ii := 0; ii < mm; ii++ {
			if dist_prefix[ii] <= D {
				left = ii
			} else {
				break
			}
		}
		right := mm
		for ii := mm - 1; ii >= 0; ii-- {
			if dist_suffix[ii] <= D {
				right = ii
			} else {
				break
			}
		}
		var m_here int64
		if left >= right {
			m_here = 1
		} else {
			m_here = int64(right - left + 1)
		}
		return m_here <= int64(k)
	}

	lo, hi := int64(0), int64(1000000000000000000)
	for lo < hi {
		mid := (lo + hi) / 2
		if check(mid) {
			hi = mid
		} else {
			lo = mid + 1
		}
	}
	fmt.Fprintln(out, lo)
}

func max(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}
```