#include <bits/stdc++.h>

#define rep(i, j, k) for (int i = (j); i <= (k); ++i)
#define per(i, j, k) for (int i = (j); i >= (k); --i)
#define SZ(v) int((v).size())
#define ALL(v) (v).begin(),(v).end()
#define fi first
#define se second
using ll = long long;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;

template<class T> void chkmn(T &x, T y) { if (y < x) x = y; }
template<class T> void chkmx(T &x, T y) { if (y > x) x = y; }

using namespace std;

const int maxn = 400010;
const int maxm = maxn * 20;

struct node {
  int cnt, mx, rmx;
  node() { cnt = 0, mx = rmx = -1e9; }
  node(int x, int v) {
    if (!v) cnt = 0, mx = x, rmx = -1e9;
    else cnt = v, mx = rmx = x + v;
  }
  friend node operator+(node x, node y) {
    node res;
    res.cnt = x.cnt + y.cnt;
    res.mx = max(x.mx + y.cnt, y.mx);
    res.rmx = max(x.rmx + y.cnt, y.rmx);
    if (y.cnt) chkmx(res.rmx, x.mx + y.cnt);
    return res;
  }
} t[maxm];

int n, m, p[maxn], deg[maxn], a[maxn], b[maxn], vis[maxn], lt, jump[maxn], ls[maxm], rs[maxm], tot, ans;
int lid[maxn], idx[maxn], bel[maxn], dep[maxn], dfn[maxn], sz[maxn], timer, rt[maxn];
vector<int> ins[maxn], del[maxn], e[maxn], loop[maxn];
vector<pii> vec[maxn];
queue<int> q;

void dfs(int u, int rt) {
  bel[u] = rt, sz[u] = 1, dfn[u] = ++timer;
  for (int v : e[u]) dep[v] = dep[u] + 1, dfs(v, rt), sz[u] += sz[v];
}

int getdis(int x, int y) {
  assert(lid[x] == lid[y]);
  if (idx[x] <= idx[y]) return idx[y] - idx[x];
  else return SZ(loop[lid[x]]) - idx[x] + idx[y];
}

#define mid ((l + r) >> 1)

void upd(int &p, int l, int r, int x, int v) {
  if (!p) p = ++tot, t[p] = node(0, 0);
  if (l == r) return t[p] = node(x, t[p].cnt + v), void();
  if (x <= mid) upd(ls[p], l, mid, x, v);
  else upd(rs[p], mid + 1, r, x, v);
  t[p] = t[ls[p]] + t[rs[p]];
}

int merge(int p, int q, int l, int r) {
  if (!p || !q) return p ^ q;
  if (l == r) return t[p] = node(l, t[p].cnt + t[q].cnt), p;
  ls[p] = merge(ls[p], ls[q], l, mid);
  rs[p] = merge(rs[p], rs[q], mid + 1, r);
  t[p] = t[ls[p]] + t[rs[p]];
  return p;
}

node qry(int p, int l, int r, int x, int y) {
  if (l == x && r == y) return t[p];
  if (y <= mid) return qry(ls[p], l, mid, x, y);
  else if (x > mid) return qry(rs[p], mid + 1, r, x, y);
  else return qry(ls[p], l, mid, x, mid) + qry(rs[p], mid + 1, r, mid + 1, y);
}

#undef mid

void dfs(int u) {
  for (int v : e[u]) dfs(v), rt[u] = merge(rt[u], rt[v], 0, n);
  for (int x : ins[u]) upd(rt[u], 0, n, x, 1);
  for (int x : del[u]) upd(rt[u], 0, n, x, -1);
  node res = qry(rt[u], 0, n, dep[u], n);
  chkmx(ans, res.rmx - dep[u]);
}

int main() {
  cin.tie(nullptr) -> ios::sync_with_stdio(false);
  cin >> n;
  rep (i, 1, n) cin >> p[i], deg[p[i]]++;
  cin >> m;
  rep (i, 1, m) cin >> a[i] >> b[i];
  rep (i, 1, n) if (!deg[i]) q.emplace(i);
  while (!q.empty()) {
    int u = q.front();
    q.pop();
    if (!--deg[p[u]]) q.emplace(p[u]);
  }
  rep (i, 1, n) if (deg[i] && !vis[i]) {
    int x = i;
    lt++;
    while (!vis[x]) {
      vis[x] = 1, lid[x] = lt, idx[x] = SZ(loop[lt]);
      loop[lt].emplace_back(x), x = p[x];
    }
  }
  rep (i, 1, n) if (!vis[i]) e[p[i]].emplace_back(i);
  rep (i, 1, n) if (vis[i]) dfs(i, i);
  vector<pii> cur;
  rep (i, 1, m) {
    int x = a[i], y = b[i];
    if (bel[x] == bel[y]) {
      if (dfn[x] < dfn[y] || dfn[x] >= dfn[y] + sz[y]) return cout << "-1\n", 0;
      ins[x].emplace_back(dep[x]), del[y].emplace_back(dep[x]);
    } else if (!vis[y]) {
      return cout << "-1\n", 0;
    } else if (lid[bel[x]] != lid[bel[y]]) {
      return cout << "-1\n", 0;
    } else {
      ins[x].emplace_back(dep[x]), vec[bel[x]].emplace_back(dep[x], idx[y]);
    }
  }
  rep (i, 1, n) if (vis[i]) dfs(i);
  rep (i, 1, lt) {
    int len = SZ(loop[i]), rt = 0;
    rep (j, 0, 2 * len - 1) ins[j].clear(), del[j].clear();
    rep (j, 0, len - 1) {
      for (auto [val, tar] : vec[loop[i][j]]) {
        if (tar > j) {
          ins[j].emplace_back(val - j), del[tar].emplace_back(val - j);
          ins[j + len].emplace_back(val - (j + len)), del[tar + len].emplace_back(val - (j + len));
        } else {
          ins[j].emplace_back(val - j), del[tar + len].emplace_back(val - j);
          ins[j + len].emplace_back(val - (j + len));
        }
      }
    }
    rep (j, 0, 2 * len - 1) {
      for (int x : ins[j]) upd(rt, -n, n, x, 1);
      for (int x : del[j]) upd(rt, -n, n, x, -1);
      chkmx(ans, t[rt].rmx + j);
    }
  }
  cout << ans << '\n';
}