#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
const int INF = 1e9;
struct Tree {
  vector<int> data;
  int sz;
  void init(int n, int* a) {
    sz = n;
    data.resize(sz * 4);
    rec(0, 0, n, a);
  }
  void rec(int v, int ll, int rr, int* a) {
    if (ll + 1 == rr) {
      data[v] = a[ll];
      return;
    }
    rec(v * 2 + 1, ll, (ll + rr) / 2, a);
    rec(v * 2 + 2, (ll + rr) / 2, rr, a);
    data[v] = min(data[v * 2 + 1], data[v * 2 + 2]);
  }
  int getAndSet(int v, int ll, int rr, int val) {
    if (ll + 1 == rr) {
      if (data[v] > val) {
        return -1;
      }
      data[v] = INF;
      return ll;
    }
    int res = -1;
    if (data[v * 2 + 1] <= val)
      res = getAndSet(v * 2 + 1, ll, (ll + rr) / 2, val);
    else if (data[v * 2 + 2] <= val)
      res = getAndSet(v * 2 + 2, (ll + rr) / 2, rr, val);
    data[v] = min(data[v * 2 + 1], data[v * 2 + 2]);
    return res;
  }
  void set(int v, int ll, int rr, int pos, int val) {
    if (ll + 1 == rr) {
      data[v] = val;
      return;
    }
    if (pos < (ll + rr) / 2)
      set(v * 2 + 1, ll, (ll + rr) / 2, pos, val);
    else
      set(v * 2 + 2, (ll + rr) / 2, rr, pos, val);
    data[v] = min(data[v * 2 + 1], data[v * 2 + 2]);
  }
};
int n, m;
int h[N];
int s[N];
vector<int> e[N];
vector<int> g[N];
int dist[N];
bool use[N];
vector<int> nodes;
priority_queue<pair<int, int> > q;
int answer = INF;
vector<vector<int> > values;
vector<vector<int> > valuesUp;
int h2[N];
int h3[N];
int res[N];
int cur;
Tree t;
void addE(int v, int u) {
  g[v].push_back(u);
  g[u].push_back(v);
}
void read() {
  scanf("%d", &n);
  for (int i = 0; i < n; i++) scanf("%d", &h[i]);
  for (int i = 0; i < n - 1; i++) {
    int v, u;
    scanf("%d%d", &v, &u);
    v--;
    u--;
    addE(v, u);
  }
  scanf("%d", &m);
  for (int i = 0; i < m; i++) scanf("%d", &s[i]);
}
void make(int l, int r, vector<int>& back) {
  for (int i = l; i < r; i++) {
    for (int j = 0; j < (int)values[i].size(); j++) {
      int tmp = t.getAndSet(0, 0, t.sz, values[i][j]);
      if (tmp == -1) {
        break;
      }
      back.push_back(tmp);
    }
  }
}
void ret(vector<int>& back) {
  for (int i = 0; i < (int)back.size(); i++)
    t.set(0, 0, t.sz, back[i], s[back[i] + cur]);
}
void go(int v) {
  vector<int> back;
  for (int i = 0; i < (int)valuesUp[v].size(); i++) {
    int tmp = t.getAndSet(0, 0, t.sz, valuesUp[v][i]);
    if (tmp == -1) break;
    back.push_back(tmp);
  }
  if (t.data[0] == INF) answer = min(answer, res[v]);
  ret(back);
}
void f(int l, int r) {
  if (l == r) assert(false);
  if (l + 1 == r) {
    go(l);
    return;
  }
  vector<int> back;
  make((l + r) / 2, r, back);
  f(l, (l + r) / 2);
  ret(back);
  back.clear();
  make(l, (l + r) / 2, back);
  f((l + r) / 2, r);
  ret(back);
}
void dfs0(int v, int hh) {
  hh = min(hh, h[v]);
  h2[v] = hh;
  use[v] = 1;
  for (auto u : g[v]) {
    if (!use[u]) {
      e[v].push_back(u);
      dfs0(u, hh);
    }
  }
}
void dfs1(int v, int id) {
  values[id].push_back(h2[v]);
  for (auto u : e[v]) dfs1(u, id);
}
void dfs3(int v, int flag, int id, int hh) {
  if (flag == -1) hh = min(h[v], hh);
  h3[v] = hh;
  valuesUp[id].push_back(h3[v]);
  for (auto u : e[v]) dfs3(u, -1, id, hh);
}
void solve() {
  memset(use, 0, sizeof(use));
  dfs0(0, INF);
  sort(s, s + m, greater<int>());
  dist[0] = h[0];
  q.push(make_pair(h[0], 0));
  cur = 0;
  while (!q.empty() && cur < m) {
    pair<int, int> pr = q.top();
    if (pr.first < s[cur]) break;
    int v = pr.second;
    q.pop();
    for (auto u : e[v]) {
      dist[u] = min(dist[v], h[u]);
      q.push(make_pair(dist[u], u));
    }
    cur++;
  }
  if (cur == m) {
    printf("0\n");
    return;
  }
  int needH = s[cur];
  t.init(m - cur, s + cur);
  for (; !q.empty();) {
    nodes.push_back(q.top().second);
    q.pop();
  }
  for (int i = 0; i < (int)nodes.size(); i++) {
    res[i] = needH - dist[nodes[i]];
    assert(res[i] > 0);
  }
  values.resize(nodes.size());
  for (int i = 0; i < (int)nodes.size(); i++) {
    dfs1(nodes[i], i);
    sort(values[i].begin(), values[i].end(), greater<int>());
  }
  valuesUp.resize(nodes.size());
  for (int i = 0; i < (int)nodes.size(); i++) {
    dfs3(nodes[i], 1, i, needH);
    sort(valuesUp[i].begin(), valuesUp[i].end(), greater<int>());
  }
  f(0, nodes.size());
  if (answer == INF)
    printf("-1\n");
  else
    printf("%d\n", answer);
}
void printAns() {}
void stress() {
  for (int t = 0; t < 1; t++) {
    cerr << "test id: " << t << endl;
    n = 500000;
    for (int i = 0; i < n; i++) h[i] = 1;
    h[0] = 100;
    for (int i = 0; i < n - 1; i++) {
      addE(0, i + 1);
    }
    m = n;
    for (int i = 0; i < m; i++) s[i] = 2;
    solve();
  }
}
int main() {
  if (1) {
    int k = 1;
    for (int tt = 0; tt < k; tt++) {
      read();
      solve();
      printAns();
    }
  } else {
    stress();
  }
  return 0;
}
