#include"bits/stdc++.h"
using namespace std;
#define REP(k,m,n) for(int (k)=(m);(k)<(n);(k)++)
#define rep(i,n) REP((i),0,(n))
using ll = long long;
using pii = pair<int, int>;


using Graph = vector<vector<int>>;
struct HLDecomposition {
    using pii = pair<int, int>;
    int n;
    Graph G;
    vector<int> vid, inv, par, depth, subsize, head, prev, next, type;

    HLDecomposition(const Graph& G_) :
        n(G_.size()), G(G_),
        vid(n, -1), inv(n), par(n), depth(n), subsize(n, 1),
        head(n), prev(n, -1), next(n, -1), type(n) {}
    void build(vector<int> roots = { 0 }) {
        int curtype = 0, pos = 0;
        for (int root : roots) {
            decide_heavy_edge(root);
            reconstruct(root, curtype++, pos);
        }
    }
    void decide_heavy_edge(int root) {
        stack<pii> st;
        par[root] = -1, depth[root] = 0;
        st.emplace(root, 0);
        while (!st.empty()) {
            int now = st.top().first;
            int& way = st.top().second;
            if (way < G[now].size()) {
                int child = G[now][way++];
                if (child == par[now])continue;
                par[child] = now;
                depth[child] = depth[now] + 1;
                st.emplace(child, 0);
            }
            else {
                st.pop();
                int maxsize = 0;
                for (auto child : G[now]) {
                    if (child == par[now])continue;
                    subsize[now] += subsize[child];
                    if (maxsize < subsize[child]) {
                        maxsize = subsize[child];
                        prev[child] = now;
                        next[now] = child;
                    }
                }
            }
        }
    }
    void reconstruct(int root, int curtype, int& pos) {
        stack<int> st({ root });
        while (!st.empty()) {
            int start = st.top(); st.pop();
            for (int v = start; v != -1; v = next[v]) {
                type[v] = curtype;
                vid[v] = pos++;
                inv[vid[v]] = v;
                head[v] = start;
                for (auto child : G[v]) {
                    if (child != par[v] && child != next[v]) {
                        st.push(child);
                    }
                }
            }
        }
    }
    int lca(int u, int v) {
        while (true) {
            if (vid[u] > vid[v])swap(u, v);
            if (head[u] == head[v])return u;
            v = par[head[v]];
        }
    }
};

bool is_kadomatsu(int a, int b, int c) {
    return a != b && b != c && c != a && (a < b != b < c);
}

int main()
{
    int N, Q;
    cin >> N;
    vector<int> A(N);
    vector<vector<int>> edges(N);
    rep(i, N)cin >> A[i];
    rep(i, N - 1) {
        int x, y;
        cin >> x >> y;
        x--; y--;
        edges[x].push_back(y);
        edges[y].push_back(x);
    }
    HLDecomposition hld(edges);
    hld.build();

    vector<int> depth(N), par(N), lim(N);
    {
        stack<pii> st;
        st.push({ -1,0 });
        while (!st.empty()) {
            int p, n;
            tie(p, n) = st.top(); st.pop();
            depth[n] = (p == -1 ? 0 : depth[p] + 1);
            par[n] = p;
            lim[n] = p == -1 ? n
                : par[p] == -1 ? p
                : is_kadomatsu(A[n], A[p], A[par[p]]) ? lim[p] : p;
            for (int next : edges[n])if (next != p)st.push({ n,next });
        }
    }

    cin >> Q;
    while (Q--) {
        int u, v;
        cin >> u >> v;
        u--; v--;
        if (depth[u] < depth[v])swap(u, v);

        bool res = true;
        res &= (depth[u] + depth[v]) % 2 == 1;
        res &= is_kadomatsu(A[par[u]], A[u], A[v]);
        res &= par[v] == -1 || is_kadomatsu(A[u], A[v], A[par[v]]);
        res &= max(depth[lim[u]], depth[lim[v]]) <= depth[hld.lca(u, v)];
        cout << (res ? "YES" : "NO") << endl;
    }
    return 0;
}