/**
 * @file heat-2.cpp
 * @author n685
 * @brief
 * @date 2024-06-17
 *
 *
 */
#include <bits/stdc++.h>

#ifdef LOCAL
#include "dd/debug.h"
#else
#define dbg(...) 42
#define dbgR(...) 4242
#define dbgP(...) 420
#define dbgRP(...) 420420
void nline() {}
#endif

const int INF = static_cast<int>(1e9 + 1e8);

template <class T> auto psum(const std::vector<T> &v, int l, int r) -> T {
  if (l > r) {
    return T(0);
  } else if (l == 0) {
    return v[r];
  } else {
    return v[r] - v[l - 1];
  }
}

void sub1(std::vector<int> &c, std::vector<int> &x) {
  int ans = 0;
  for (auto &i : x) {
    if (c[i + 1] == 0) {
      if (c[i] == 0) {
        ++ans;
      } else {
        --c[i];
      }
    } else {
      --c[i + 1];
    }
  }
  std::cout << ans << '\n';
}

auto main() -> int {
#ifndef LOCAL
  std::cin.tie(nullptr)->sync_with_stdio(false);
#endif

  int l;
  std::cin >> l;
  std::vector<int> c(l);
  for (int i = 0; i < l; ++i) {
    std::cin >> c[i];
  }
  int n;
  std::cin >> n;
  std::vector<int> x(n);
  std::vector<std::vector<int>> id(l - 1);
  bool s1 = true;
  for (int i = 0; i < n; ++i) {
    std::cin >> x[i];
    --x[i];
    id[x[i]].push_back(i + 1);
    if (i > 0 && x[i - 1] > x[i]) {
      s1 = false;
    }
  }
  if (s1) {
    sub1(c, x);
    return 0;
  }
  std::vector<int> z(l - 1);
  for (int i = 0; i < l - 1; ++i) {
    z[i] = static_cast<int>(id[i].size());
  }

  std::vector pre(1, std::vector<int>(n + 1));
  for (int i = 0; i < l - 1; ++i) {
    std::vector cur(std::min(c[i + 1], z[i]) + 1,
                    std::vector<int>(n + 1, -INF));
    std::vector<int> num(n + 1);
    for (int j : id[i]) {
      ++num[j];
    }
    std::partial_sum(num.begin(), num.end(), num.begin());
    for (int j = 0; j < std::ssize(cur); ++j) {
      for (int t = 0; t <= n; ++t) {
        int b = psum(num, 0, t);
        int jp = c[i] - (b - j);
        if (0 <= jp && jp < std::ssize(pre) && j <= b) {
          for (int tp = 0; tp < t; ++tp) {
            if (psum(num, tp + 1, t) <= j) {
              cur[j][t] = std::max(cur[j][t], pre[jp][tp] + (z[i] - b));
            }
          }
        }
      }
    }
    for (int j = 0; j < std::ssize(cur); ++j) {
      for (int t = 0; t <= n; ++t) {
        if (j <= psum(num, 0, t)) {
          for (int tp = t; tp < n; ++tp) {
            int b = psum(num, 0, std::max(t, tp));
            int jp = c[i] - (b - j);
            if (0 <= jp && jp < std::ssize(pre)) {
              cur[j][t] = std::max(cur[j][t], pre[jp][tp] + (z[i] - b));
            }
          }
        }
      }
    }
    for (int j = 0; j < std::ssize(cur); ++j) {
      for (int t = 0; t <= n; ++t) {
        int tp = n, b = z[i];
        if ((tp < t && psum(num, tp + 1, t) <= j && j <= b) ||
            (tp >= t && j <= psum(num, 0, t))) {
          for (int jp = 0;
               jp <= std::min(static_cast<int>(pre.size()) - 1, c[i] - (b - j));
               ++jp) {
            cur[j][t] = std::max(cur[j][t], pre[jp][tp] + (z[i] - b));
          }
        }
      }
    }
    pre = cur;
  }
  int ans = 0;
  for (int j = 0; j < std::ssize(pre); ++j) {
    for (int t = 0; t <= n; ++t) {
      if ((t == n && j <= c[l - 1]) || (t < n && j == c[l - 1])) {
        ans = std::max(ans, pre[j][t]);
      }
    }
  }
  std::cout << ans << '\n';
}