#include <bits/stdc++.h>
using namespace std;
int N;
vector<pair<int, int> > G[100005];
int Number[100005], TT[100005], R[100005];
long long Down[100005], Up[100005], Max[100005], Max2[100005], P[100005];
int Ord[100005];
map<int, int> S;
inline bool cmp(int a, int b) {
  return max(Down[a], Up[a]) < max(Down[b], Up[b]);
}
void Read() {
  scanf("%d", &N);
  for (int i = 1; i < N; i++) {
    int x, y, v;
    Ord[i] = i;
    scanf("%d%d%d", &x, &y, &v);
    G[x].push_back(make_pair(y, v));
    G[y].push_back(make_pair(x, v));
  }
  Ord[N] = N;
}
void DFS(int node, int father) {
  for (int i = 0; i < G[node].size(); i++) {
    int neighb = G[node][i].first, cost = G[node][i].second;
    if (neighb == father) continue;
    DFS(neighb, node);
    Down[node] = max(Down[neighb] + cost, Down[node]);
    if (Max[node] < Down[neighb] + cost) {
      Max2[node] = Max[node];
      Max[node] = Down[neighb] + cost;
    } else if (Max2[node] < Down[neighb] + cost)
      Max2[node] = Down[neighb] + cost;
  }
}
void DFS2(int node, int father, int cost) {
  if (node != 1) {
    Up[node] = Up[father] + cost;
    if (Max[father] == Down[node] + cost)
      Up[node] = max(Up[node], Max2[father] + cost);
    else
      Up[node] = max(Up[node], Max[father] + cost);
  }
  for (int i = 0; i < G[node].size(); i++) {
    int neighb = G[node][i].first, cost = G[node][i].second;
    if (neighb == father) continue;
    DFS2(neighb, node, cost);
  }
}
void Unite(int x, int y) {
  if (x == y) return;
  if (R[x] < R[y]) {
    swap(x, y);
    TT[y] = x;
    Number[x] += Number[y];
    if (S.find(Number[y]) != S.end()) {
      S[Number[y]]--;
      if (S[Number[y]] == 0) S.erase(Number[y]);
    }
    if (S.find(Number[x] - Number[y]) != S.end()) {
      S[Number[x] - Number[y]]--;
      if (S[Number[x] - Number[y]] == 0) S.erase(Number[x] - Number[y]);
    }
    S[Number[x]]++;
    swap(x, y);
  } else {
    TT[y] = x;
    Number[x] += Number[y];
    if (S.find(Number[y]) != S.end()) {
      S[Number[y]]--;
      if (S[Number[y]] == 0) S.erase(Number[y]);
    }
    if (S.find(Number[x] - Number[y]) != S.end()) {
      S[Number[x] - Number[y]]--;
      if (S[Number[x] - Number[y]] == 0) S.erase(Number[x] - Number[y]);
    }
    S[Number[x]]++;
  }
  if (R[x] == R[y]) ++R[x];
}
int Father(int x) {
  int init = x;
  while (x != TT[x]) x = TT[x];
  while (init != x) {
    int next = TT[init];
    TT[init] = x;
    init = next;
  }
  return x;
}
void Query(long long L) {
  int right = N, left = N;
  for (int i = 1; i <= N; i++) TT[i] = i, R[i] = 1, Number[i] = 1;
  S.clear();
  int ans = 0;
  for (; right >= 1; right--) {
    while (left >= 1 && max(Down[Ord[right]], Up[Ord[right]]) -
                                max(Down[Ord[left]], Up[Ord[left]]) <=
                            L) {
      S[Number[Ord[left]]]++;
      for (int i = 0; i < G[Ord[left]].size(); i++) {
        int neighb = G[Ord[left]][i].first;
        if (P[neighb] >= left && P[neighb] <= right) {
          Unite(Father(neighb), Father(Ord[left]));
        }
      }
      --left;
    }
    ans = max(ans, prev(S.end())->first);
    int f = Father(Ord[right]);
    if (S.find(Number[f]) != S.end()) {
      S[Number[f]]--;
      if (S[Number[f]] == 0) S.erase(Number[f]);
    }
    Number[f]--;
    S[Number[f]]++;
  }
  printf("%d\n", ans);
}
int main() {
  Read();
  DFS(1, 0);
  DFS2(1, 0, 0);
  sort(Ord + 1, Ord + N + 1, cmp);
  int Q;
  for (int i = 1; i <= N; i++) P[Ord[i]] = i;
  scanf("%d", &Q);
  for (int i = 1; i <= Q; i++) {
    long long L;
    scanf("%I64d", &L);
    Query(L);
  }
  return 0;
}
