import std.algorithm, std.conv, std.range, std.stdio, std.string; void main() { auto n = readln.chomp.to!size_t; auto a = new int[](n), rd1 = readln.chomp.splitter(' '); foreach (i; 0..n) { a[i] = rd1.front.to!int; rd1.popFront(); } auto isKadomatsu(size_t i1, size_t i2, size_t i3) { auto v1 = a[i1], v2 = a[i2], v3 = a[i3]; return v1 != v2 && v2 != v3 && v3 != v1 && (v1 > v2 && v3 > v2 || v1 < v2 && v3 < v2); } auto tree = Tree(n); foreach (_; 0..n-1) { auto rd2 = readln.chomp.splitter(' '); auto u = rd2.front.to!size_t-1; rd2.popFront(); auto v = rd2.front.to!size_t-1; tree.addEdge(u, v); } tree.rootify(0); tree.makePath(0); auto pathKadomatsu = new SparseTable!(bool, "a & b")[](tree.paths.length); foreach (i, path; tree.paths) { auto pl = path.length; if (pl >= 3) { auto b = new bool[](pl-2); foreach (j; 0..pl-2) b[j] = isKadomatsu(path[j], path[j+1], path[j+2]); pathKadomatsu[i] = SparseTable!(bool, "a & b")(b); } } struct AKR { bool r; size_t uchild; } auto allKadomatsu(size_t u, size_t v) { size_t head; while (tree.path[u] != tree.path[v]) { auto pathNo = tree.path[v], path = tree.paths[pathNo]; auto d = tree.depthInPath(v); head = path[0]; auto headParent = tree.parent[head]; if (d >= 2 && !pathKadomatsu[pathNo][0..d-1] || path.length >= 2 && d >= 1 && !isKadomatsu(headParent, head, path[1]) || headParent != u && !isKadomatsu(tree.parent[headParent], headParent, head)) { return AKR(false, 0); } v = headParent; } auto pathNo = tree.path[v], path = tree.paths[pathNo]; auto d1 = tree.depthInPath(u), d2 = tree.depthInPath(v); if (d2 - d1 >= 3 && !pathKadomatsu[pathNo][d1..d2-1]) return AKR(false, 0); return AKR(true, u == v ? head : path[d1+1]); } auto calc(size_t u, size_t v) { auto lca = tree.lca(u, v); if (lca == v) swap(u, v); if (tree.parent[v] == u) return false; if (lca == u) { auto r = allKadomatsu(u, v); if (!r.r || !isKadomatsu(tree.parent[v], v, u) || !isKadomatsu(v, u, r.uchild)) return false; return true; } else { auto r1 = allKadomatsu(lca, u); auto r2 = allKadomatsu(lca, v); if (!r1.r || !r2.r || !isKadomatsu(r1.uchild, lca, r2.uchild) || !isKadomatsu(tree.parent[u], u, v) || !isKadomatsu(u, v, tree.parent[v])) return false; return true; } } auto q = readln.chomp.to!size_t; foreach (_; 0..q) { auto rd3 = readln.chomp.splitter; auto u = rd3.front.to!size_t-1; rd3.popFront(); auto v = rd3.front.to!size_t-1; writeln(calc(u, v) ? "YES" : "NO"); } } struct Tree { import std.container; size_t n; size_t[][] adj; int[] size, depth; size_t[] head, parent, path; size_t[][] paths; this(size_t n) { this.n = n; adj = new size_t[][](n); } auto addEdge(size_t s, size_t t) { adj[s] ~= t; adj[t] ~= s; } auto rootify(size_t r) { parent = new size_t[](n); depth = new int[](n); depth[] = -1; struct UP { size_t u, p; } auto st1 = SList!UP(UP(r, r)); auto st2 = SList!UP(); while (!st1.empty) { auto up = st1.front, u = up.u, p = up.p; st1.removeFront(); parent[u] = p; depth[u] = depth[p] + 1; foreach (v; adj[u]) if (v != p) { st1.insertFront(UP(v, u)); st2.insertFront(UP(v, u)); } } size = new int[](n); size[] = 1; while (!st2.empty) { auto up = st2.front, u = up.u, p = up.p; st2.removeFront(); size[p] += size[u]; } head = new size_t[](n); head[] = n; struct US { size_t u, s; } auto st = SList!US(US(r, r)); while (!st.empty) { auto us = st.front, u = us.u, s = us.s; st.removeFront(); head[u] = s; auto z = n; foreach (v; adj[u]) if (head[v] == n && (z == n || size[z] < size[v])) z = v; foreach (v; adj[u]) if (head[v] == n) st.insertFront(US(v, v == z ? s : v)); } } auto makePath(size_t r) { auto pathIndex = 0; path = new size_t[](n); auto q = DList!size_t(r); while (!q.empty) { auto u = q.front; q.removeFront(); if (u == head[u]) { path[u] = pathIndex++; paths ~= [u]; } else { path[u] = path[head[u]]; paths[path[u]] ~= u; } foreach (v; adj[u]) if (v != parent[u]) q.insertBack(v); } } auto depthInPath(size_t n) { return depth[n] - depth[head[n]]; } auto lca(size_t u, size_t v) { while (head[u] != head[v]) if (depth[head[u]] < depth[head[v]]) v = parent[head[v]]; else u = parent[head[u]]; return depth[u] < depth[v] ? u : v; } } struct SparseTable(T, alias pred = "a < b ? a : b") { import std.algorithm, std.functional; alias predFun = binaryFun!pred; size_t[] logTable; size_t[][] rmq; size_t n; T[] a; this(T[] a) { this.a = a; this.n = a.length; logTable = new size_t[n + 1]; foreach (i; 2..n+1) logTable[i] = logTable[i >> 1] + 1; rmq = new size_t[][](logTable[n] + 1, n); foreach (i; 0..n) rmq[0][i] = i; for (size_t k = 1; (1 << k) < n; ++k) for (size_t i = 0; i + (1 << k) <= n; ++i) { auto x = rmq[k - 1][i]; auto y = rmq[k - 1][i + (1 << k - 1)]; rmq[k][i] = predFun(a[x], a[y]) == a[x] ? x : y; } } pure size_t opDollar() const { return n; } pure T opSlice(size_t l, size_t r) const { auto k = logTable[r - l - 1]; auto x = rmq[k][l]; auto y = rmq[k][r - (1 << k)]; return predFun(a[x], a[y]); } }