#include <bits/stdc++.h>
using namespace std;
struct _ {
  ios_base::Init i;
  _() {
    cin.sync_with_stdio(0);
    cin.tie(0);
  }
} _;
struct DisjointSet {
  int par[100100];
  int num[100100];
  void init(int n) {
    for (int i = (0); i < (n); ++i) {
      par[i] = i;
      num[i] = 1;
    }
  }
  int find(int x) { return par[x] == x ? x : (par[x] = find(par[x])); }
  void unions(int x, int y) {
    int rx = find(x);
    int ry = find(y);
    if (rx == ry) {
      return;
    }
    if (num[rx] < num[ry]) {
      swap(rx, ry);
    }
    par[ry] = rx;
    num[rx] += num[ry];
  }
};
vector<pair<int, int>> adj[100100];
long long max_dist[100100][2];
long long farthest[100100];
long long direct_par[100100];
vector<pair<long long, int>> ranked_node;
void dfs_rooted(int u, int p) {
  for (auto pr : adj[u]) {
    if (pr.first != p) {
      dfs_rooted(pr.first, u);
      long long dist = max_dist[pr.first][0] + pr.second;
      if (dist > max_dist[u][0]) {
        max_dist[u][1] = max_dist[u][0];
        max_dist[u][0] = dist;
      } else if (dist > max_dist[u][1]) {
        max_dist[u][1] = dist;
      }
    }
  }
}
void dfs_unrooted(int u, int p, long long p_max_dist) {
  farthest[u] = max(max_dist[u][0], p_max_dist);
  for (auto pr : adj[u]) {
    int v = pr.first;
    long long c = pr.second;
    if (v == p) {
      continue;
    }
    if (max_dist[u][0] == max_dist[v][0] + c) {
      dfs_unrooted(v, u, max(p_max_dist, max_dist[u][1]) + c);
    } else {
      dfs_unrooted(v, u, max(p_max_dist, max_dist[u][0]) + c);
    }
  }
}
void dfs_reroot(int u, int p) {
  direct_par[u] = p;
  for (auto pr : adj[u]) {
    if (pr.first != p) {
      dfs_reroot(pr.first, u);
    }
  }
}
int main(int argc, char **argv) {
  int N, Q;
  cin >> N;
  for (int i = (0); i < (N - 1); ++i) {
    int x, y, z;
    cin >> x >> y >> z;
    --x, --y;
    adj[x].push_back(make_pair(y, z));
    adj[y].push_back(make_pair(x, z));
  }
  dfs_rooted(0, 0);
  dfs_unrooted(0, 0, 0);
  int root = 0;
  for (int i = (0); i < (N); ++i) {
    if (farthest[i] < farthest[root]) {
      root = i;
    }
    ranked_node.push_back(make_pair(farthest[i], i));
  }
  dfs_reroot(root, root);
  sort(ranked_node.begin(), ranked_node.end());
  cin >> Q;
  DisjointSet dset;
  for (int q = (0); q < (Q); ++q) {
    long long L;
    cin >> L;
    dset.init(N);
    int ptr = N - 1;
    int res = 0;
    for (int i = (N - 1); i >= (0); --i) {
      int u = ranked_node[i].second;
      for (auto pr : adj[u]) {
        int v = pr.first;
        if (v != direct_par[u]) {
          dset.unions(u, v);
        }
      }
      int v;
      while (v = ranked_node[ptr].second, farthest[v] > farthest[u] + L) {
        dset.num[dset.find(v)]--;
        ptr--;
      }
      res = max(res, dset.num[dset.find(u)]);
    }
    cout << res << endl;
  }
  return 0;
}
