package main

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

type Edge struct {
	to int
	w  int64
}

type Child struct {
	to int
	w  int64
}

type Item struct {
	v  int
	w  int64
	P  int64
	sz int
}

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

	var n int
	if _, err := fmt.Fscan(in, &n); err != nil {
		return
	}

	adj := make([][]Edge, n+1)
	for i := 0; i < n-1; i++ {
		var a, b int
		var t int64
		fmt.Fscan(in, &a, &b, &t)
		adj[a] = append(adj[a], Edge{to: b, w: t})
		adj[b] = append(adj[b], Edge{to: a, w: t})
	}

	children := make([][]Child, n+1)
	parent := make([]int, n+1)
	order := make([]int, 0, n)
	stack := make([]int, 0, n)
	stack = append(stack, 1)
	parent[1] = -1
	for len(stack) > 0 {
		u := stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		order = append(order, u)
		for _, e := range adj[u] {
			if e.to == parent[u] {
				continue
			}
			parent[e.to] = u
			children[u] = append(children[u], Child{to: e.to, w: e.w})
			stack = append(stack, e.to)
		}
	}

	sz := make([]int, n+1)
	edgeSum := make([]int64, n+1)
	F := make([]int64, n+1)

	for i := len(order) - 1; i >= 0; i-- {
		u := order[i]
		base := 0
		if u != 1 {
			base = 1
		}
		szu := base
		esu := int64(0)
		for _, ch := range children[u] {
			v := ch.to
			w := ch.w
			szu += sz[v]
			esu += w + edgeSum[v]
		}
		sz[u] = szu
		edgeSum[u] = esu

		if len(children[u]) == 0 {
			F[u] = 0
			continue
		}

		items := make([]Item, len(children[u]))
		for idx, ch := range children[u] {
			v := ch.to
			P := 2 * (ch.w + edgeSum[v])
			items[idx] = Item{v: v, w: ch.w, P: P, sz: sz[v]}
		}
		sort.Slice(items, func(i, j int) bool {
			x := items[i].P * int64(items[j].sz)
			y := items[j].P * int64(items[i].sz)
			if x != y {
				return x < y
			}
			return items[i].v < items[j].v
		})

		var Fu int64 = 0
		var D int64 = 0
		for _, it := range items {
			Fu += F[it.v]
			Fu += int64(it.sz) * it.w
			Fu += int64(it.sz) * D
			D += it.P
		}
		F[u] = Fu
	}

	ans := float64(F[1]) / float64(n-1)
	fmt.Fprintf(out, "%.10f\n", ans)
}