package main

import (
	"fmt"
	"io"
	"os"
)

type Scanner struct {
	buf []byte
	pos int
}

func NewScanner(r io.Reader) *Scanner {
	buf, _ := io.ReadAll(r)
	return &Scanner{buf: buf, pos: 0}
}

func (s *Scanner) NextInt() int {
	for s.pos < len(s.buf) && s.buf[s.pos] <= ' ' {
		s.pos++
	}
	if s.pos >= len(s.buf) {
		return 0
	}
	res := 0
	for s.pos < len(s.buf) && s.buf[s.pos] > ' ' {
		res = res*10 + int(s.buf[s.pos]-'0')
		s.pos++
	}
	return res
}

func (s *Scanner) NextInt64() int64 {
	for s.pos < len(s.buf) && s.buf[s.pos] <= ' ' {
		s.pos++
	}
	if s.pos >= len(s.buf) {
		return 0
	}
	res := int64(0)
	for s.pos < len(s.buf) && s.buf[s.pos] > ' ' {
		res = res*10 + int64(s.buf[s.pos]-'0')
		s.pos++
	}
	return res
}

func main() {
	scanner := NewScanner(os.Stdin)
	n := scanner.NextInt()
	if n == 0 {
		return
	}

	adj := make([][]int, n+1)
	for i := 0; i < n-1; i++ {
		u := scanner.NextInt()
		v := scanner.NextInt()
		adj[u] = append(adj[u], v)
		adj[v] = append(adj[v], u)
	}

	x := make([]int64, n+1)
	y := make([]int64, n+1)
	var sumX, sumY int64
	for i := 1; i <= n; i++ {
		x[i] = scanner.NextInt64()
		y[i] = scanner.NextInt64()
		sumX += x[i]
		sumY += y[i]
	}

	size := make([]int, n+1)
	sumXsub := make([]int64, n+1)
	children := make([][]int, n+1)
	order := make([]int, 0, n)

	queue := make([]int, 0, n)
	queue = append(queue, 1)
	visited := make([]bool, n+1)
	visited[1] = true

	for len(queue) > 0 {
		u := queue[0]
		queue = queue[1:]
		order = append(order, u)

		for _, v := range adj[u] {
			if !visited[v] {
				visited[v] = true
				children[u] = append(children[u], v)
				queue = append(queue, v)
			}
		}
	}

	for i := len(order) - 1; i >= 0; i-- {
		u := order[i]
		size[u] = 1
		sumXsub[u] = x[u]
		for _, v := range children[u] {
			size[u] += size[v]
			sumXsub[u] += sumXsub[v]
		}
	}

	var totalSub float64 = 0
	fSumX := float64(sumX)
	fSumY := float64(sumY)
	fN := float64(n)

	for i := 1; i <= n; i++ {
		if y[i] == 0 {
			continue
		}
		var term float64 = 0
		term += (float64(x[i]) / fSumX) * fN
		term += (float64(sumX-sumXsub[i]) / fSumX) * float64(size[i])
		for _, v := range children[i] {
			term += (float64(sumXsub[v]) / fSumX) * float64(n-size[v])
		}
		totalSub += (float64(y[i]) / fSumY) * term
	}

	ans := fN - totalSub
	if ans < 0 {
		ans = 0
	}
	fmt.Printf("%.10f\n", ans)
}