```go
package main

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

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

	value := make([]int, 2*n+1)
	count := make([]int, n+1)
	in_S := make([]bool, 2*n+1)

	for i := 1; i <= 2*n; i++ {
		fmt.Fscan(reader, &value[i])
		count[value[i]]++
		in_S[i] = true
	}

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

	parent := make([]int, 2*n+1)
	val_vis := make([]int, n+1)
	val_vis_id := 0

	for i := 2 * n; i >= 1; i-- {
		if !in_S[i] {
			continue
		}

		var neighbors []int
		for _, v := range adj[i] {
			if in_S[v] {
				neighbors = append(neighbors, v)
			}
		}

		d := len(neighbors)
		if d == 0 {
			continue
		}
		if d == 1 {
			if count[value[i]] > 1 {
				in_S[i] = false
				count[value[i]]--
			}
			continue
		}

		queues := make([][]int, d)
		comp_nodes := make([][]int, d)
		finished := make([]bool, d)
		active := d

		for j, v := range neighbors {
			queues[j] = make([]int, 0, 4)
			queues[j] = append(queues[j], v)
			comp_nodes[j] = make([]int, 0, 4)
			comp_nodes[j] = append(comp_nodes[j], v)
			parent[v] = 0
		}

		for active > 1 {
			for j := 0; j < d; j++ {
				if finished[j] {
					continue
				}

				u := queues[j][0]
				queues[j] = queues[j][1:]

				for _, v := range adj[u] {
					if v == i || v == parent[u] {
						continue
					}
					if in_S[v] {
						parent[v] = u
						queues[j] = append(queues[j], v)
						comp_nodes[j] = append(comp_nodes[j], v)
					}
				}

				if len(queues[j]) == 0 {
					finished[j] = true
					active--
					if active <= 1 {
						break
					}
				}
			}
		}

		valid_comp := -1
		for j := 0; j < d; j++ {
			if finished[j] {
				unique := 0
				val_vis_id++
				for _, u := range comp_nodes[j] {
					val := value[u]
					if val_vis[val] != val_vis_id {
						val_vis[val] = val_vis_id
						unique++
					}
				}
				if unique == n {
					valid_comp = j
					break
				}
			}
		}

		if valid_comp != -1 {
			keep_neighbor := neighbors[valid_comp]
			q := []int{i}
			in_S[i] = false
			count[value[i]]--

			for len(q) > 0 {
				u := q[0]
				q = q[1:]
				for _, v := range adj[u] {
					if u == i && v == keep_neighbor {
						continue
					}
					if in_S[v] {
						in_S[v] = false
						count[value[v]]--
						q = append(q, v)
					}
				}
			}
		} else {
			var removed_nodes []int
			removed_nodes = append(removed_nodes, i)
			for j := 0; j < d; j++ {
				if finished[j] {
					removed_nodes = append(removed_nodes, comp_nodes[j]...)
				}
			}

			valid_c_star := true
			for _, u := range removed_nodes {
				val := value[u]
				count[val]--
				if count[val] == 0 {
					valid_c_star = false
				}
			}

			if valid_c_star {
				for _, u := range removed_nodes {
					in_S[u] = false
				}
			} else {
				for _, u := range removed_nodes {
					count[value[u]]++
				}
			}
		}
	}

	ans := make([]int, 0)
	for i := 1; i <= 2*n; i++ {
		if in_S[i] {
			ans = append(ans, i)
		}
	}
	fmt.Println(len(ans))
	for i, u := range ans {
		if i > 0 {
			fmt.Print(" ")
		}
		fmt.Print(u)
	}
	fmt.Println()
}
```