#include <bits/stdc++.h>
using namespace std;
struct node {
  int next, to;
} e[1000005];
struct Segment_Tree {
  int l, r, pre, tag;
} t[2000005];
bool vis[500005];
vector<int> vec[500005];
pair<int, int> mn[500005];
int head[500005], h[500005], b[500005], s[500005], g, k;
int read() {
  int A;
  bool K;
  char C;
  C = A = K = 0;
  while (C < '0' || C > '9') K |= C == '-', C = getchar();
  while (C > '/' && C < ':') A = (A << 3) + (A << 1) + (C ^ 48), C = getchar();
  return (K ? -A : A);
}
inline void add(int u, int v) {
  e[++g].to = v;
  e[g].next = head[u];
  head[u] = g;
}
inline void pushup(int p) {
  t[p].pre =
      ((t[((p) << 1)].pre) < (t[((p) << 1 | 1)].pre) ? t[((p) << 1)].pre
                                                     : t[((p) << 1 | 1)].pre);
}
void build(int p, int l, int r) {
  t[p].l = l;
  t[p].r = r;
  if (l == r) return;
  int mid = (l + r) >> 1;
  build(((p) << 1), l, mid), build(((p) << 1 | 1), mid + 1, r);
}
inline void pushdown(int p) {
  if (t[p].tag) {
    t[((p) << 1)].pre += t[p].tag;
    t[((p) << 1 | 1)].pre += t[p].tag;
    t[((p) << 1)].tag += t[p].tag;
    t[((p) << 1 | 1)].tag += t[p].tag;
    t[p].tag = 0;
  }
}
void change(int p, int x, int y, int z) {
  if (x > y) return;
  if (x <= t[p].l && t[p].r <= y) {
    t[p].pre += z;
    t[p].tag += z;
    return;
  }
  pushdown(p);
  if (t[((p) << 1)].r >= x) change(((p) << 1), x, y, z);
  if (t[((p) << 1 | 1)].l <= y) change(((p) << 1 | 1), x, y, z);
  pushup(p);
}
int ask(int p, int x, int y) {
  if (x <= t[p].l && t[p].r <= y) return t[p].pre;
  int ret = INT_MAX, tmp;
  pushdown(p);
  if (t[((p) << 1)].r >= x) ret = ask(((p) << 1), x, y);
  if (t[((p) << 1 | 1)].l <= y)
    tmp = ask(((p) << 1 | 1), x, y), ret = ((ret) < (tmp) ? ret : tmp);
  return ret;
}
void dfs(int u, int fa) {
  int i, v;
  mn[u].first = mn[fa].first;
  mn[u].second = mn[fa].second;
  if (h[u] < h[mn[u].first])
    mn[u].second = mn[u].first, mn[u].first = u;
  else if (h[u] < h[mn[u].second])
    mn[u].second = u;
  vec[mn[u].first].push_back(u);
  b[u] = h[mn[u].first];
  for (i = head[u]; i; i = e[i].next) {
    v = e[i].to;
    if (v != fa) dfs(v, u);
  }
}
bool check(int u, int x) {
  int i;
  bool bo;
  for (i = 0; i <= (vec[u].size() - 1); i++)
    change(1,
           lower_bound(
               s + 1, s + k + 1,
               ((h[mn[vec[u][i]].second]) < (h[u] + x) ? h[mn[vec[u][i]].second]
                                                       : h[u] + x),
               greater<int>()) -
               s,
           lower_bound(s + 1, s + k + 1, h[u], greater<int>()) - s - 1, 1);
  bo = ask(1, 1, k) >= 0;
  for (i = 0; i <= (vec[u].size() - 1); i++)
    change(1,
           lower_bound(
               s + 1, s + k + 1,
               ((h[mn[vec[u][i]].second]) < (h[u] + x) ? h[mn[vec[u][i]].second]
                                                       : h[u] + x),
               greater<int>()) -
               s,
           lower_bound(s + 1, s + k + 1, h[u], greater<int>()) - s - 1, -1);
  return bo;
}
int main() {
  int n, i, x, y, res = INT_MAX, mx = 0, tmp;
  n = read();
  for (i = 1; i <= (n); i++) h[i] = read();
  for (i = 1; i <= (n - 1); i++) {
    x = read(), y = read();
    add(x, y), add(y, x);
  }
  k = read();
  for (i = 1; i <= (k); i++) s[i] = read();
  h[0] = INT_MAX;
  dfs(1, 0);
  sort(s + 1, s + k + 1, greater<int>());
  sort(b + 1, b + n + 1, greater<int>());
  build(1, 1, k);
  for (i = 1; i <= (k); i++) {
    tmp = upper_bound(b + 1, b + n + 1, s[i], greater<int>()) - b - 1 - i;
    change(1, i, i, tmp);
    if (tmp < 0) mx = ((s[i]) > (mx) ? s[i] : mx);
  }
  if (ask(1, 1, k) >= 0) cout << 0, exit(0);
  for (i = 1; i <= (n); i++) {
    if (vis[mn[i].first]) continue;
    vis[mn[i].first] = 1;
    if (check(mn[i].first, mx - h[mn[i].first]))
      res = ((res) < (mx - h[mn[i].first]) ? res : mx - h[mn[i].first]);
  }
  cout << (res == INT_MAX ? -1 : res);
  return 0;
}
