#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;             }           } else if (lp != rp) {             if (b >= s[lp]) {               umx(cur, s[lp] - a);               ++lp;             } else {               ok = false;             }           }         }         if (ok && fail_from == fail_to && lp == rp && (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;   }