#include <bits/stdc++.h>
using namespace std;
int n;
int h[500100];
int s[500100];
int ss[500100];
int hs[500100];
bool vis[500100];
vector<int> G[500100];
vector<int> tree[500100];
void make_tree(int u = 0) {
  vis[u] = 1;
  for (int c : G[u])
    if (!vis[c]) {
      tree[u].push_back(c);
      make_tree(c);
    }
  return;
}
void get_neck(int u, int mn) {
  mn = min(mn, h[u]);
  hs[u] = mn;
  for (int c : tree[u]) get_neck(c, mn);
}
struct node {
  int mn, carry;
  void split(node& l, node& r) {
    l.carry += carry;
    r.carry += carry;
    l.mn += carry;
    r.mn += carry;
    carry = 0;
  }
  void merge(node& l, node& r) {
    mn = min(l.mn, r.mn);
    carry = 0;
  }
  void update(int v) {
    mn += v;
    carry += v;
  }
} seg_tree[2000001];
void update(int rt, int l, int r, int i, int j, int val) {
  if (l >= i && j >= r) return seg_tree[rt].update(val);
  int m = (l + r) / 2, lft = 2 * rt, rgt = lft + 1;
  seg_tree[rt].split(seg_tree[lft], seg_tree[rgt]);
  if (i <= m) update(lft, l, m, i, j, val);
  if (j >= m + 1) update(rgt, m + 1, r, i, j, val);
  seg_tree[rt].merge(seg_tree[lft], seg_tree[rgt]);
}
void update(int l, int r, int v) {
  if (l > r) return;
  return update(1, 1, n, l, r, v);
}
int get_min() { return seg_tree[1].mn; }
int how_many(vector<int>& v, int x) {
  int id = lower_bound(v.begin(), v.end(), x) - v.begin();
  return n - id;
}
void dfs(int u, int mn) {
  int y = upper_bound(ss, ss + n, hs[u]) - ss;
  update(n - y + 1, n, -1);
  y = upper_bound(ss, ss + n, mn) - ss;
  update(n - y + 1, n, +1);
  for (int c : tree[u]) {
    dfs(c, min(mn, h[c]));
  }
}
void dfs1(int u, int mn) {
  int y = upper_bound(ss, ss + n, hs[u]) - ss;
  update(n - y + 1, n, +1);
  y = upper_bound(ss, ss + n, mn) - ss;
  update(n - y + 1, n, -1);
  for (int c : tree[u]) {
    dfs1(c, min(mn, h[c]));
  }
}
int main() {
  int k;
  scanf("%d", &n);
  for (int i = 0; i < n; ++i) {
    scanf("%d", h + i);
  }
  for (int i = 0; i < n - 1; ++i) {
    int u, v;
    scanf("%d %d", &u, &v);
    u -= 1;
    v -= 1;
    G[u].push_back(v);
    G[v].push_back(u);
  }
  scanf("%d", &k);
  for (int i = 0; i < k; ++i) {
    scanf("%d", s + i);
  }
  sort(s, s + k, greater<int>());
  for (int i = 0; i < n; ++i) ss[n - 1 - i] = s[i];
  make_tree();
  priority_queue<pair<int, int> > pq;
  pq.push({h[0], 0});
  int i = 0;
  while (i < k) {
    pair<int, int> p = pq.top();
    if (p.first < s[i]) break;
    pq.pop();
    for (int c : tree[p.second]) pq.push({h[c], c});
    i += 1;
  }
  if (i == k) {
    cout << "0\n";
    return 0;
  }
  get_neck(0, 1000000007);
  vector<int> v(hs, hs + n);
  sort(v.begin(), v.end());
  for (int i = 0; i < n; ++i) {
    int hw = how_many(v, s[i]);
    update(i + 1, i + 1, hw - (i + 1));
  }
  assert(get_min() < 0);
  while (!pq.empty()) {
    pair<int, int> p = pq.top();
    pq.pop();
    int tmp = p.first;
    dfs(p.second, s[i]);
    if (get_min() >= 0) {
      cout << s[i] - tmp << "\n";
      return 0;
    }
    dfs1(p.second, s[i]);
  }
  cout << -1 << "\n";
  return 0;
}
