package main

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

type Edge struct {
	u, v, id int
	w        int64
}

var (
	in    []int
	out   []int
	adj   [][]int
	timer int
)

func dfs(u, p int) {
	isLeaf := true
	in[u] = 1e9
	out[u] = -1e9
	for _, v := range adj[u] {
		if v != p {
			isLeaf = false
			dfs(v, u)
			if in[v] < in[u] {
				in[u] = in[v]
			}
			if out[v] > out[u] {
				out[u] = out[v]
			}
		}
	}
	if isLeaf && u != 1 {
		timer++
		in[u] = timer
		out[u] = timer
	}
}

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

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

	c := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		fmt.Fscan(reader, &c[i])
	}

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

	in = make([]int, n+1)
	out = make([]int, n+1)
	dfs(1, 0)

	edges := make([]Edge, 0, n)
	for i := 1; i <= n; i++ {
		if in[i] <= out[i] {
			edges = append(edges, Edge{
				u:  in[i],
				v:  out[i] + 1,
				w:  c[i],
				id: i,
			})
		}
	}

	sort.Slice(edges, func(i, j int) bool {
		return edges[i].w < edges[j].w
	})

	parent := make([]int, timer+2)
	for i := 1; i <= timer+1; i++ {
		parent[i] = i
	}

	var find func(int) int
	find = func(i int) int {
		if parent[i] == i {
			return i
		}
		parent[i] = find(parent[i])
		return parent[i]
	}

	union := func(i, j int) {
		rootI := find(i)
		rootJ := find(j)
		if rootI != rootJ {
			parent[rootI] = rootJ
		}
	}

	current_components := timer + 1
	var total_cost int64
	var valid_edges []int

	for i := 0; i < len(edges); {
		j := i
		for j < len(edges) && edges[j].w == edges[i].w {
			j++
		}

		comps_before := current_components

		for k := i; k < j; k++ {
			if find(edges[k].u) != find(edges[k].v) {
				valid_edges = append(valid_edges, edges[k].id)
			}
		}

		for k := i; k < j; k++ {
			if find(edges[k].u) != find(edges[k].v) {
				union(edges[k].u, edges[k].v)
				current_components--
			}
		}

		total_cost += int64(comps_before-current_components) * edges[i].w
		i = j
	}

	sort.Ints(valid_edges)

	fmt.Fprintln(writer, total_cost, len(valid_edges))
	for i, id := range valid_edges {
		if i > 0 {
			fmt.Fprint(writer, " ")
		}
		fmt.Fprint(writer, id)
	}
	fmt.Fprintln(writer)
}