```go
package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	buf := make([]byte, 1024*1024)
	scanner.Buffer(buf, 10*1024*1024)
	scanner.Split(bufio.ScanWords)

	readInt := func() int {
		scanner.Scan()
		res := 0
		for _, b := range scanner.Bytes() {
			res = res*10 + int(b-'0')
		}
		return res
	}

	if !scanner.Scan() {
		return
	}
	res := 0
	for _, b := range scanner.Bytes() {
		res = res*10 + int(b-'0')
	}
	n := res
	k := readInt()

	a := make([]int, n+1)
	max_a := 0
	for i := 1; i <= n; i++ {
		a[i] = readInt()
		if a[i] > max_a {
			max_a = a[i]
		}
	}

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

	W := make([]int, n+1)
	D := make([]int, n+1)
	is_good := make([]bool, n+1)
	visited := make([]bool, n+1)
	Q := make([]int, 0, n+1)

	check := func(X int) bool {
		for i := 1; i <= n; i++ {
			is_good[i] = (a[i] >= X)
			W[i] = 1
			D[i] = len(adj[i])
			visited[i] = false
		}

		Q = Q[:0]
		for i := 1; i <= n; i++ {
			if is_good[i] && D[i] <= 1 {
				Q = append(Q, i)
			}
		}

		max_ans := 0

		for head := 0; head < len(Q); head++ {
			u := Q[head]
			if W[u] > max_ans {
				max_ans = W[u]
			}
			D[u] = 0
			for _, v := range adj[u] {
				if D[v] > 0 {
					W[v] += W[u]
					D[v]--
					if is_good[v] && D[v] == 1 {
						Q = append(Q, v)
					}
				}
			}
		}

		if max_ans >= k {
			return true
		}

		var dfs func(u, p int) int
		dfs = func(u, p int) int {
			visited[u] = true
			max1, max2 := 0, 0
			for _, v := range adj[u] {
				if is_good[v] && D[v] > 0 && v != p {
					r := dfs(v, u)
					if r > max1 {
						max2 = max1
						max1 = r
					} else if r > max2 {
						max2 = r
					}
				}
			}
			if max1+max2+W[u] > max_ans {
				max_ans = max1 + max2 + W[u]
			}
			return max1 + W[u]
		}

		for i := 1; i <= n; i++ {
			if is_good[i] && D[i] > 0 && !visited[i] {
				dfs(i, 0)
				if max_ans >= k {
					return true
				}
			}
		}

		return max_ans >= k
	}

	L := 1
	R := max_a
	ans := 1

	for L <= R {
		mid := L + (R-L)/2
		if check(mid) {
			ans = mid
			L = mid + 1
		} else {
			R = mid - 1
		}
	}

	fmt.Println(ans)
}
```