package main

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

type Edge struct {
	to int
	w  int64
}

func farthest(start int, adj [][]Edge) (int, []int64) {
	n := len(adj) - 1
	dist := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		dist[i] = -1
	}
	order := make([]int, 0, n)
	order = append(order, start)
	dist[start] = 0
	for i := 0; i < len(order); i++ {
		v := order[i]
		for _, e := range adj[v] {
			if dist[e.to] == -1 {
				dist[e.to] = dist[v] + e.w
				order = append(order, e.to)
			}
		}
	}
	far := start
	for i := 1; i <= n; i++ {
		if dist[i] > dist[far] {
			far = i
		}
	}
	return far, dist
}

func buildEuler(root int, adj [][]Edge) ([]int, []int) {
	n := len(adj) - 1
	tin := make([]int, n+1)
	tout := make([]int, n+1)

	stackV := make([]int, 1, n)
	stackP := make([]int, 1, n)
	stackI := make([]int, 1, n)
	stackV[0] = root
	stackP[0] = 0
	stackI[0] = 0

	timer := 0
	for len(stackV) > 0 {
		top := len(stackV) - 1
		v := stackV[top]
		if stackI[top] == 0 {
			timer++
			tin[v] = timer
		}
		if stackI[top] < len(adj[v]) {
			e := adj[v][stackI[top]]
			stackI[top]++
			if e.to == stackP[top] {
				continue
			}
			stackV = append(stackV, e.to)
			stackP = append(stackP, v)
			stackI = append(stackI, 0)
		} else {
			tout[v] = timer
			stackV = stackV[:top]
			stackP = stackP[:top]
			stackI = stackI[:top]
		}
	}

	return tin, tout
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	nextInt := func() int64 {
		for idx < len(data) && (data[idx] < '0' || data[idx] > '9') {
			idx++
		}
		var x int64
		for idx < len(data) && data[idx] >= '0' && data[idx] <= '9' {
			x = x*10 + int64(data[idx]-'0')
			idx++
		}
		return x
	}

	n := int(nextInt())
	adj := make([][]Edge, n+1)
	for i := 0; i < n-1; i++ {
		x := int(nextInt())
		y := int(nextInt())
		w := nextInt()
		adj[x] = append(adj[x], Edge{y, w})
		adj[y] = append(adj[y], Edge{x, w})
	}

	a, _ := farthest(1, adj)
	b, distA := farthest(a, adj)
	_, distB := farthest(b, adj)
	d := distA[b]

	dep2 := make([]int64, n+1)
	root := 1
	for i := 1; i <= n; i++ {
		mx := distA[i]
		if distB[i] > mx {
			mx = distB[i]
		}
		dep2[i] = mx*2 - d
		if dep2[i] < dep2[root] {
			root = i
		}
	}

	tin, tout := buildEuler(root, adj)

	ord := make([]int, n)
	for i := 0; i < n; i++ {
		ord[i] = i + 1
	}
	sort.Slice(ord, func(i, j int) bool {
		if dep2[ord[i]] == dep2[ord[j]] {
			return ord[i] < ord[j]
		}
		return dep2[ord[i]] < dep2[ord[j]]
	})

	q := int(nextInt())
	bit := make([]int, n+2)

	writer := bufio.NewWriterSize(os.Stdout, 1<<20)
	for qi := 0; qi < q; qi++ {
		l := nextInt()
		L2 := l * 2

		for i := 1; i <= n; i++ {
			bit[i] = 0
		}

		p := 0
		best := 0

		for _, x := range ord {
			limit := dep2[x] + L2
			for p < n && dep2[ord[p]] <= limit {
				pos := tin[ord[p]]
				for pos <= n {
					bit[pos]++
					pos += pos & -pos
				}
				p++
			}

			sum := 0
			r := tout[x]
			for r > 0 {
				sum += bit[r]
				r -= r & -r
			}
			lft := tin[x] - 1
			for lft > 0 {
				sum -= bit[lft]
				lft -= lft & -lft
			}
			if sum > best {
				best = sum
			}
		}

		writer.WriteString(strconv.Itoa(best))
		writer.WriteByte('\n')
	}
	writer.Flush()
}