#include <bits/stdc++.h>
using namespace std;
template <typename T>
T mabs(const T &a) {
  return a < 0 ? -a : a;
}
const int SZ = 500500;
struct vert {
  vector<int> inc;
  vector<pair<int, int> > vec;
  bool was = false;
  int h;
  int currH;
} g[SZ];
inline void updatePair(pair<pair<int, int>, pair<int, int> > &arr,
                       const pair<int, int> &p) {
  if (p.first < arr.first.first) {
    arr.second = arr.first;
    arr.first = p;
    return;
  }
  if (p.first < arr.second.first) arr.second = p;
}
void dfs(int k, pair<pair<int, int>, pair<int, int> > mn) {
  updatePair(mn, pair<int, int>(g[k].h, k));
  g[k].was = true;
  for (int i = (0), ei = (g[k].inc.size()); i < ei; i++) {
    int to = g[k].inc[i];
    if (!g[to].was) dfs(to, mn);
  }
  int mx = mn.second.first;
  g[k].h = g[k].currH = mn.first.first;
  g[mn.first.second].vec.push_back(pair<int, int>(mx, k));
}
int D[4 * SZ];
int Add[4 * SZ];
int A[SZ];
void build(int v, int l, int r) {
  Add[v] = 0;
  if (l == r) {
    D[v] = A[l];
    return;
  }
  int c = (l + r) / 2;
  build(2 * v, l, c);
  build(2 * v + 1, c + 1, r);
  D[v] = min(D[2 * v], D[2 * v + 1]);
}
void addVal(int v, int l, int r, int ql, int qr, int val) {
  if (ql > qr) return;
  if (l == ql && r == qr) {
    Add[v] += val;
    D[v] += val;
    return;
  }
  int c = (l + r) / 2;
  if (qr <= c)
    addVal(2 * v, l, c, ql, qr, val);
  else if (ql > c)
    addVal(2 * v + 1, c + 1, r, ql, qr, val);
  else {
    addVal(2 * v, l, c, ql, c, val);
    addVal(2 * v + 1, c + 1, r, c + 1, qr, val);
  }
  D[v] = min(D[2 * v], D[2 * v + 1]) + Add[v];
}
int getVal(int v, int l, int r, int ql, int qr) {
  if (l == ql && r == qr) return D[v];
  int c = (l + r) / 2;
  if (qr <= c) return getVal(2 * v, l, c, ql, qr) + Add[v];
  if (ql > c) return getVal(2 * v + 1, c + 1, r, ql, qr) + Add[v];
  return min(getVal(2 * v, l, c, ql, c),
             getVal(2 * v + 1, c + 1, r, c + 1, qr)) +
         Add[v];
}
int getMaxNeg(int v, int l, int r, int add) {
  if (l == r) return l;
  int c = (l + r) / 2;
  if (D[2 * v + 1] + Add[v] + add >= 0)
    return getMaxNeg(2 * v, l, c, add + Add[v]);
  return getMaxNeg(2 * v + 1, c + 1, r, add + Add[v]);
}
int getPosInSt(int *S, int m, int val) {
  return upper_bound(S, S + m, val) - S - 1;
}
int S[SZ];
const int INF = 1e9 + 100;
void run() {
  int n;
  cin >> n;
  for (int i = (0), ei = (n); i < ei; i++) {
    scanf("%d", &g[i].h);
  }
  for (int i = (0), ei = (n - 1); i < ei; i++) {
    int a, b;
    scanf("%d%d", &a, &b);
    --a;
    --b;
    g[a].inc.push_back(b);
    g[b].inc.push_back(a);
  }
  int m;
  cin >> m;
  for (int i = (0), ei = (m); i < ei; i++) scanf("%d", S + i);
  sort(S, S + m);
  pair<pair<int, int>, pair<int, int> > mn(pair<int, int>(INF, 0),
                                           pair<int, int>(INF, 0));
  dfs(0, mn);
  for (int i = (0), ei = (n); i < ei; i++)
    sort((g[i].vec).begin(), (g[i].vec).end());
  for (int i = (0), ei = (m); i < ei; i++) A[i] = -m + i;
  build(1, 0, m - 1);
  for (int i = (0), ei = (n); i < ei; i++) {
    int pos = getPosInSt(S, m, g[i].currH);
    if (pos == -1) continue;
    addVal(1, 0, m - 1, 0, pos, 1);
  }
  if (getVal(1, 0, m - 1, 0, m - 1) >= 0) {
    puts("0");
    return;
  }
  int res = INF;
  for (int i = (0), ei = (n); i < ei; i++) {
    for (int j = (0), ej = (g[i].vec.size()); j < ej; j++) {
      int val = g[i].vec[j].first;
      int maxNegPos = getMaxNeg(1, 0, m - 1, 0);
      val = min(val, S[maxNegPos]);
      val = max(val, g[i].currH);
      int v = g[i].vec[j].second;
      int add = 1;
      if (v != i) {
        int posCurr = getPosInSt(S, m, g[i].currH);
        addVal(1, 0, m - 1, 0, posCurr, -1);
        g[i].currH = val;
        add = 2;
      }
      int posV = getPosInSt(S, m, g[v].currH);
      addVal(1, 0, m - 1, 0, posV, -1);
      g[v].currH = val;
      int posNew = getPosInSt(S, m, g[v].currH);
      addVal(1, 0, m - 1, 0, posNew, add);
      int mn = getVal(1, 0, m - 1, 0, m - 1);
      if (mn >= 0) res = min(res, g[i].currH - g[i].h);
    }
    for (int j = (0), ej = (g[i].vec.size()); j < ej; j++) {
      int v = g[i].vec[j].second;
      int posCurr = getPosInSt(S, m, g[v].currH);
      addVal(1, 0, m - 1, 0, posCurr, -1);
      g[v].currH = g[v].h;
      int posNew = getPosInSt(S, m, g[v].currH);
      addVal(1, 0, m - 1, 0, posNew, 1);
    }
  }
  if (res == INF) res = -1;
  cout << res << endl;
}
int main() {
  run();
  return 0;
}
