```go
package main

import (
	"bufio"
	"container/heap"
	"fmt"
	"os"
	"sort"
)

type Edge struct {
	to  int
	cap int
}

type Item struct {
	idx  int
	time int
}

var priorities []int

type IntHeap []int

func (h IntHeap) Len() int           { return len(h) }
func (h IntHeap) Less(i, j int) bool { return priorities[h[i]] < priorities[h[j]] }
func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
func (h *IntHeap) Push(x interface{}) { *h = append(*h, x.(int)) }
func (h *IntHeap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[:n-1]
	return x
}

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

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

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

	parent := make([]int, n+1)
	capToParent := make([]int, n+1)
	order := make([]int, 0, n)
	
	queue := []int{1}
	parent[1] = 0
	for len(queue) > 0 {
		v := queue[0]
		queue = queue[1:]
		order = append(order, v)
		for _, e := range adj[v] {
			if e.to != parent[v] {
				parent[e.to] = v
				capToParent[e.to] = e.cap
				queue = append(queue, e.to)
			}
		}
	}

	arrivals := make([][]Item, n+1)
	for i := 1; i <= n; i++ {
		arrivals[i] = append(arrivals[i], Item{i, 0})
	}

	for i := len(order) - 1; i > 0; i-- {
		v := order[i]
		capacity := capToParent[v]
		p := parent[v]
		
		sort.Slice(arrivals[v], func(i, j int) bool {
			return arrivals[v][i].time < arrivals[v][j].time
		})

		pq := &IntHeap{}
		heap.Init(pq)
		day := 0
		idx := 0
		list := arrivals[v]

		for idx < len(list) || pq.Len() > 0 {
			for idx < len(list) && list[idx].time <= day {
				heap.Push(pq, list[idx].idx)
				idx++
			}
			if pq.Len() == 0 {
				day = list[idx].time
				continue
			}
			take := capacity
			if pq.Len() < take {
				take = pq.Len()
			}
			for k := 0; k < take; k++ {
				divIdx := heap.Pop(pq).(int)
				arrivals[p] = append(arrivals[p], Item{divIdx, day + 1})
			}
			day++
		}
		arrivals[v] = nil
	}

	ans := make([]int, n+1)
	for _, item := range arrivals[1] {
		ans[item.idx] = item.time
	}

	for i := 1; i <= n; i++ {
		if i > 1 {
			fmt.Fprint(writer, " ")
		}
		fmt.Fprint(writer, ans[i])
	}
	fmt.Fprintln(writer)
}
```