#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
  return x * x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
  if (b < a) {
    a = b;
    return 1;
  }
  return 0;
}
struct Input {
  int n, k;
  vector<vector<int> > g;
  vector<int> h;
  vector<int> s;
  bool read() {
    if (!(cin >> n)) {
      return 0;
    }
    h.resize(n);
    for (int i = int(0); i < int(n); ++i) {
      cin >> h[i];
    }
    g.assign(n, vector<int>());
    for (int i = int(0); i < int(n - 1); ++i) {
      int u, v;
      cin >> u >> v;
      --u, --v;
      g[u].push_back(v);
      g[v].push_back(u);
    }
    cin >> k;
    s.resize(k);
    for (int i = int(0); i < int(k); ++i) {
      cin >> s[i];
    }
    return 1;
  }
  void init(const Input& input) { *this = input; }
};
struct Data : Input {
  int ans;
  void write() { cout << ans << '\n'; }
  virtual void solve() {}
  virtual void clear() { *this = Data(); }
};
struct Solution : Data {
  vector<int> sc_best;
  vector<int> fs_best;
  vector<int> all_vals;
  vector<int> heights;
  vector<int> backw_pos;
  vector<int> forw_pos;
  vector<int> fail_pos;
  vector<int> fail_vers;
  void dfs(int x, int par, int first, int second) {
    if (first == -1 || h[x] <= h[first]) {
      second = first;
      first = x;
    } else if (second == -1 || h[x] <= h[second]) {
      second = x;
    }
    fs_best[x] = first;
    sc_best[x] = second;
    for (auto to : g[x]) {
      if (to != par) {
        dfs(to, x, first, second);
      }
    }
  }
  int mfit() {
    int ans = -1;
    int ln = 0;
    for (int i = int(0); i < int(((int)(all_vals).size())); ++i) {
      int cur = 0;
      vector<int> new_h;
      int rn = ln;
      while (rn < n && fs_best[heights[rn]] == all_vals[i]) ++rn;
      int fail_from = 0, fail_to = fail_pos[i];
      int lp = forw_pos[i], rp = backw_pos[i];
      bool ok = true;
      for (int j = int(ln); j < int(rn); ++j) {
        int a = h[all_vals[i]];
        int b = 2000000000;
        if (sc_best[heights[j]] != -1) {
          b = h[sc_best[heights[j]]];
        }
        if (fail_from != fail_to) {
          if (b >= fail_vers[fail_from]) {
            umx(cur, fail_vers[fail_from] - a);
            ++fail_from;
          } else {
            ok = false;
            break;
          }
        } else if (lp != rp) {
          if (b >= s[lp]) {
            umx(cur, s[lp] - a);
            ++lp;
          } else {
            ok = false;
            break;
          }
        }
      }
      if (ok && fail_from == fail_to && lp == rp) {
        if (ans == -1 || ans > cur) {
          ans = cur;
        }
      }
      ln = rn;
    }
    return ans;
  }
  void solve() {
    sort((s).begin(), (s).end());
    reverse((s).begin(), (s).end());
    sc_best.assign(n, -1);
    fs_best.assign(n, -1);
    dfs(0, -1, -1, -1);
    heights.resize(n);
    for (int i = int(0); i < int(n); ++i) {
      heights[i] = i;
    }
    sort((heights).begin(), (heights).end(), [&](int a, int b) {
      return (h[fs_best[a]] > h[fs_best[b]] ||
              (h[fs_best[a]] == h[fs_best[b]] && fs_best[a] < fs_best[b]) ||
              (fs_best[a] == fs_best[b] &&
               (sc_best[b] != -1 &&
                (sc_best[a] == -1 || h[sc_best[a]] > h[sc_best[b]]))));
    });
    all_vals.clear();
    for (auto x : heights) {
      if (all_vals.empty() || all_vals.back() != fs_best[x]) {
        all_vals.push_back(fs_best[x]);
      }
    }
    int lp = 0, ln = 0;
    int cnt = ((int)(all_vals).size());
    forw_pos.assign(cnt, 0);
    fail_pos.assign(cnt, 0);
    for (int i = int(0); i < int(cnt - 1); ++i) {
      while (ln < n && fs_best[heights[ln]] == all_vals[i]) {
        int cur_h = h[all_vals[i]];
        while (lp < k && cur_h < s[lp]) {
          fail_vers.push_back(s[lp]);
          ++lp;
        }
        if (lp < k) {
          ++lp;
        }
        ++ln;
      }
      forw_pos[i + 1] = lp;
      fail_pos[i + 1] = ((int)(fail_vers).size());
    };
    backw_pos.assign(cnt, k);
    int rp = k - 1, rn = n - 1;
    for (int i = int(cnt) - 1; i >= int(1); --i) {
      while (rn >= 0 && fs_best[heights[rn]] == all_vals[i]) {
        int cur_h = h[all_vals[i]];
        if (rp >= 0) {
          if (cur_h >= s[rp]) {
            --rp;
          }
        }
        --rn;
      }
      backw_pos[i - 1] = rp + 1;
    }
    ans = mfit();
  }
  void clear() { *this = Solution(); }
};
Solution sol;
int main() {
  cout.setf(ios::showpoint | ios::fixed);
  cout.precision(20);
  ios_base::sync_with_stdio(false);
  sol.read();
  sol.solve();
  sol.write();
  return 0;
}
