package main

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

func main() {
	buf, _ := io.ReadAll(os.Stdin)
	pos := 0

	nextInt := func() int {
		for pos < len(buf) && (buf[pos] < '0' || buf[pos] > '9') {
			pos++
		}
		if pos >= len(buf) {
			return 0
		}
		res := 0
		for pos < len(buf) && buf[pos] >= '0' && buf[pos] <= '9' {
			res = res*10 + int(buf[pos]-'0')
			pos++
		}
		return res
	}

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

	a := make([]int, n+1)
	for i := 1; i <= n; i++ {
		a[i] = nextInt()
	}

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

	type childRes struct {
		V  map[int]struct{}
		dp int
	}

	var solve func(u, p, curXOR int) (map[int]struct{}, int)
	solve = func(u, p, curXOR int) (map[int]struct{}, int) {
		curXOR ^= a[u]

		var children []int
		for _, v := range adj[u] {
			if v != p {
				children = append(children, v)
			}
		}

		if len(children) == 0 {
			res := make(map[int]struct{}, 1)
			res[curXOR] = struct{}{}
			return res, 0
		}

		var resList []childRes
		dpSum := 0
		for _, v := range children {
			V, dp := solve(v, u, curXOR)
			resList = append(resList, childRes{V, dp})
			dpSum += dp
		}

		maxSize := -1
		largestIdx := -1
		for i, res := range resList {
			if len(res.V) > maxSize {
				maxSize = len(res.V)
				largestIdx = i
			}
		}

		L := resList[largestIdx].V
		freq := make(map[int]int)

		for i, res := range resList {
			if i == largestIdx {
				continue
			}
			for x := range res.V {
				freq[x]++
			}
		}

		maxFreq := 1
		for x, c := range freq {
			if _, ok := L[x]; ok {
				c++
			}
			if c > maxFreq {
				maxFreq = c
			}
		}

		k := len(children)

		if u == 1 {
			freqOfZero := 0
			if _, ok := L[0]; ok {
				freqOfZero = 1
			}
			if c, ok := freq[0]; ok {
				freqOfZero += c
			}

			cost1 := k - freqOfZero
			cost2 := k - maxFreq + 1
			if cost2 < cost1 {
				cost1 = cost2
			}
			return nil, dpSum + cost1
		}

		dp_u := dpSum + k - maxFreq
		if maxFreq == 1 {
			for i, res := range resList {
				if i == largestIdx {
					continue
				}
				for x := range res.V {
					L[x] = struct{}{}
				}
			}
			return L, dp_u
		}

		R := make(map[int]struct{})
		for x, c := range freq {
			if _, ok := L[x]; ok {
				c++
			}
			if c == maxFreq {
				R[x] = struct{}{}
			}
		}
		return R, dp_u
	}

	_, ans := solve(1, 0, 0)
	fmt.Println(ans)
}