```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

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

type Edge struct {
	to     int
	weight int64
}

type Pair struct {
	val int64
	id  int
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n int
	fmt.Fscan(reader, &n)

	adj := make([][]Edge, n+1)
	var totalWeight int64 = 0

	for i := 0; i < n-1; i++ {
		var u, v int
		var w int64
		fmt.Fscan(reader, &u, &v, &w)
		adj[u] = append(adj[u], Edge{v, w})
		adj[v] = append(adj[v], Edge{u, w})
		totalWeight += w
	}

	down := make([]int64, n+1)
	diam := make([]int64, n+1)

	var dfs1 func(int, int)
	dfs1 = func(u, p int) {
		var max1, max2 int64
		for _, edge := range adj[u] {
			v := edge.to
			w := edge.weight
			if v == p {
				continue
			}
			dfs1(v, u)
			diam[u] = max(diam[u], diam[v])

			d := down[v] + w
			down[u] = max(down[u], d)
			if d > max1 {
				max2 = max1
				max1 = d
			} else if d > max2 {
				max2 = d
			}
		}
		diam[u] = max(diam[u], max1+max2)
	}

	dfs1(1, 0)

	var ansMax int64 = 0

	var dfs2 func(int, int, int64, int64)
	dfs2 = func(u, p int, upVal int64, outDiamVal int64) {
		var br []Pair
		if p != 0 {
			br = append(br, Pair{upVal, p})
		}
		for _, edge := range adj[u] {
			v := edge.to
			if v != p {
				br = append(br, Pair{down[v] + edge.weight, v})
			}
		}
		sort.Slice(br, func(i, j int) bool { return br[i].val > br[j].val })

		var sumA int64
		for i := 0; i < len(br) && i < 4; i++ {
			sumA += br[i].val
		}
		ansMax = max(ansMax, sumA)

		var cdiam []Pair
		for _, edge := range adj[u] {
			v := edge.to
			if v != p {
				cdiam = append(cdiam, Pair{diam[v], v})
			}
		}
		sort.Slice(cdiam, func(i, j int) bool { return cdiam[i].val > cdiam[j].val })

		for _, edge := range adj[u] {
			v := edge.to
			w := edge.weight
			if v == p {
				continue
			}

			var upVVal int64
			for i := 0; i < len(br); i++ {
				if br[i].id != v {
					upVVal = br[i].val
					break
				}
			}

			var sum2 int64
			var count int
			for i := 0; i < len(br) && count < 2; i++ {
				if br[i].id != v {
					sum2 += br[i].val
					count++
				}
			}

			var maxCdiam int64
			for i := 0; i < len(cdiam); i++ {
				if cdiam[i].id != v {
					maxCdiam = cdiam[i].val
					break
				}
			}

			newOutDiam := outDiamVal
			if maxCdiam > newOutDiam {
				newOutDiam = maxCdiam
			}
			if sum2 > newOutDiam {
				newOutDiam = sum2
			}

			savings := 2*w + diam[v] + newOutDiam
			ansMax = max(ansMax, savings)

			dfs2(v, u, upVVal+w, newOutDiam)
		}
	}

	dfs2(1, 0, 0, 0)

	ans := 2*totalWeight - ansMax
	fmt.Println(ans)
}
```