```go
package main

import (
	"bufio"
	"io"
	"os"
	"sort"
	"strconv"
)

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data, n: len(data)}
}

func (fs *FastScanner) NextInt() int {
	for fs.idx < fs.n && (fs.data[fs.idx] < '0' || fs.data[fs.idx] > '9') {
		fs.idx++
	}
	sign := 1
	if fs.idx < fs.n && fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	val := 0
	for fs.idx < fs.n && fs.data[fs.idx] >= '0' && fs.data[fs.idx] <= '9' {
		val = val*10 + int(fs.data[fs.idx]-'0')
		fs.idx++
	}
	return val * sign
}

type Edge struct {
	u int
	v int
	w int
}

type Query struct {
	q   int
	idx int
}

type DSU struct {
	parent []int
	size   []int
}

func NewDSU(n int) *DSU {
	parent := make([]int, n+1)
	size := make([]int, n+1)
	for i := 1; i <= n; i++ {
		parent[i] = i
		size[i] = 1
	}
	return &DSU{parent: parent, size: size}
}

func (d *DSU) Find(x int) int {
	for d.parent[x] != x {
		d.parent[x] = d.parent[d.parent[x]]
		x = d.parent[x]
	}
	return x
}

func (d *DSU) Union(a, b int) int64 {
	ra := d.Find(a)
	rb := d.Find(b)
	if ra == rb {
		return 0
	}
	if d.size[ra] < d.size[rb] {
		ra, rb = rb, ra
	}
	res := int64(d.size[ra]) * int64(d.size[rb])
	d.parent[rb] = ra
	d.size[ra] += d.size[rb]
	return res
}

func main() {
	fs := NewFastScanner()
	n := fs.NextInt()
	m := fs.NextInt()

	edges := make([]Edge, n-1)
	for i := 0; i < n-1; i++ {
		edges[i] = Edge{
			u: fs.NextInt(),
			v: fs.NextInt(),
			w: fs.NextInt(),
		}
	}

	queries := make([]Query, m)
	for i := 0; i < m; i++ {
		queries[i] = Query{
			q:   fs.NextInt(),
			idx: i,
		}
	}

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

	dsu := NewDSU(n)
	ans := make([]int64, m)
	var cur int64
	e := 0

	for _, qu := range queries {
		for e < n-1 && edges[e].w <= qu.q {
			cur += dsu.Union(edges[e].u, edges[e].v)
			e++
		}
		ans[qu.idx] = cur
	}

	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	for i := 0; i < m; i++ {
		if i > 0 {
			out.WriteByte(' ')
		}
		out.WriteString(strconv.FormatInt(ans[i], 10))
	}
	out.WriteByte('\n')
	out.Flush()
}
```