```go
package main

import (
	"fmt"
	"io"
	"math/bits"
	"os"
)

func main() {
	buf := make([]byte, 65536)
	var pos, length int
	readByte := func() byte {
		if pos >= length {
			pos = 0
			var err error
			length, err = os.Stdin.Read(buf)
			if err != nil && err != io.EOF {
				panic(err)
			}
			if length == 0 {
				return 0
			}
		}
		b := buf[pos]
		pos++
		return b
	}

	readInt := func() int {
		b := readByte()
		for b <= ' ' {
			if b == 0 {
				return 0
			}
			b = readByte()
		}
		res := 0
		for b > ' ' {
			res = res*10 + int(b-'0')
			b = readByte()
		}
		return res
	}

	n := readInt()
	if n == 0 {
		return
	}

	a := make([]int64, n+1)
	minA := int64(2e18)
	R := -1
	for i := 1; i <= n; i++ {
		a[i] = int64(readInt())
		if a[i] < minA {
			minA = a[i]
			R = i
		}
	}

	head := make([]int, n+1)
	for i := 1; i <= n; i++ {
		head[i] = -1
	}
	edges := make([]int, 2*(n-1))
	next := make([]int, 2*(n-1))
	edgeCnt := 0

	addEdge := func(u, v int) {
		edges[edgeCnt] = v
		next[edgeCnt] = head[u]
		head[u] = edgeCnt
		edgeCnt++
	}

	for i := 0; i < n-1; i++ {
		u := readInt()
		v := readInt()
		addEdge(u, v)
		addEdge(v, u)
	}

	var ans int64
	path := make([]int, n+1)

	var dfs func(u, p, d int)
	dfs = func(u, p, d int) {
		path[d] = u
		if d > 0 {
			minCost := int64(2e18)
			for k := 0; (1 << k) <= d; k++ {
				anc := path[d-(1<<k)]
				cost := a[anc] * int64(1+k)
				if cost < minCost {
					minCost = cost
				}
			}
			costRoot := a[R] * int64(1+bits.Len(uint(d-1)))
			if costRoot < minCost {
				minCost = costRoot
			}
			ans += a[u] + minCost
		}

		for e := head[u]; e != -1; e = next[e] {
			v := edges[e]
			if v != p {
				dfs(v, u, d+1)
			}
		}
	}

	dfs(R, 0, 0)
	fmt.Println(ans)
}
```