#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
  cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
  const char* comma = strchr(names + 1, ',');
  cerr.write(names, comma - names) << " : " << arg1 << " | ";
  __f(comma + 1, args...);
}
const int N = int(5e5) + 10;
const int INF = int(2e9) + 10;
vector<int> g[N];
vector<pair<int, int> > affect[N];
int H[N], miners[N], A[N], T[N], ST[2][4 * N], lazy[4 * N], n;
set<pair<int, int> > second;
inline void push(int x, int l, int r) {
  ST[0][x] += lazy[x];
  ST[1][x] += (r - l) * lazy[x];
  if (l == r - 1) lazy[x] = 0;
  if (!lazy[x]) return;
  lazy[(x << 1)] += lazy[x];
  lazy[(x << 1) | 1] += lazy[x];
  lazy[x] = 0;
}
inline void up(int x) {
  ST[0][x] = min(ST[0][(x << 1)], ST[0][(x << 1) | 1]);
  ST[1][x] = ST[1][(x << 1)] + ST[1][(x << 1) | 1];
}
inline void build(int l = 1, int r = n + 1, int x = 1) {
  lazy[x] = 0;
  if (l == r - 1) return void(ST[0][x] = ST[1][x] = A[l]);
  int m = (l + r) / 2;
  build(l, m, (x << 1));
  build(m, r, (x << 1) | 1);
  up(x);
}
inline void update(int L, int R, int add, int l = 1, int r = n + 1, int x = 1) {
  push(x, l, r);
  if (l >= R || r <= L) return;
  if (l >= L && r <= R) {
    lazy[x] += add;
    push(x, l, r);
    return;
  }
  int m = (l + r) / 2;
  update(L, R, add, l, m, (x << 1));
  update(L, R, add, m, r, (x << 1) | 1);
  up(x);
}
int L[N], R[N], vis[N], last;
vector<int> spcl;
int solve() {
  int ret = INF;
  if (!last) return 0;
  for (auto i : spcl) {
    for (int j = 0; j < (int)(affect[i].size()); j++) {
      int u = affect[i][j].second, val = min(miners[last], affect[i][j].first);
      int l = L[u], r = upper_bound(miners + 1, miners + n + 1, val) - miners;
      R[j] = r;
      update(l, r, 1);
      if (ST[0][1] >= 0) ret = min(ret, val - H[i]);
    }
    for (int j = 0; j < (int)(affect[i].size()); j++) {
      int u = affect[i][j].second;
      int l = L[u], r = R[j];
      update(l, r, -1);
    }
  }
  return ret;
}
void dfs(int u, int p) {
  second.insert({H[u], u});
  auto it = second.begin();
  T[u] = it->first;
  it++;
  affect[second.begin()->second].push_back({it->first, u});
  L[u] = upper_bound(miners + 1, miners + n + 1, T[u]) - miners;
  update(0, L[u], 1);
  for (auto w : g[u])
    if (w != p) dfs(w, u);
  second.erase({H[u], u});
}
void bfs(int v) {
  last = n;
  priority_queue<pair<int, int> > Q;
  Q.push({T[v], v});
  vis[v] = 1;
  bool fucked = false;
  while (!Q.empty()) {
    pair<int, int> top = Q.top();
    Q.pop();
    int u = top.second;
    if (top.first < miners[last]) fucked = true;
    if (fucked) {
      spcl.push_back(u);
      continue;
    }
    last--;
    ;
    for (auto w : g[u])
      if (!vis[w]) {
        vis[w] = 1;
        Q.push({T[w], w});
      }
  }
}
int main() {
  scanf("%d", &n);
  for (int i = 1; i <= n; i++) scanf("%d", &H[i]);
  for (int i = 1; i < n; i++) {
    int u, v;
    scanf("%d", &u);
    scanf("%d", &v);
    g[u].push_back(v);
    g[v].push_back(u);
  }
  int k;
  scanf("%d", &k);
  for (int i = 1; i <= k; i++) scanf("%d", &miners[i]);
  k = n;
  sort(miners + 1, miners + n + 1);
  for (int i = 1; i <= n; i++) A[i] = -(n - i + 1);
  second.insert({INF, 1});
  build();
  dfs(1, 1);
  for (int i = 1; i <= n; i++) sort(affect[i].begin(), affect[i].end());
  bfs(1);
  int ans = solve();
  if (ans == INF) ans = -1;
  printf("%d\n", ans);
  return 0;
}
