#include <bits/stdc++.h>
template <class T = int>
struct BinaryIndexedTree {
  int size;
  int logSize;
  std::vector<T> tree;
  BinaryIndexedTree(int size)
      : size(size),
        logSize(sizeof(T) * 8 - __builtin_clz(size) - 1),
        tree(size + 1) {}
  void add(int index, T value) {
    assert(index >= 1 && index <= size);
    while (index <= size) {
      tree[index] += value;
      index += index & (-index);
    }
  }
  T getSum(int index) {
    assert(index <= size);
    T sum = T();
    while (index > 0) {
      sum += tree[index];
      index -= index & (-index);
    }
    return sum;
  }
  T getSum(int l, int r) { return getSum(r) - getSum(l - 1); }
  int lowerBound(T value) {
    T sum = T();
    int pos = 0;
    for (int i = logSize; i >= 0; i--) {
      if (pos + (1 << i) < size && sum + tree[pos + (1 << i)] < value) {
        sum += tree[pos + (1 << i)];
        pos += (1 << i);
      }
    }
    return pos + 1;
  }
};
const int MAXN = 500005;
struct State {
  int pos;
  long long cost;
};
std::vector<int> indices[MAXN];
int a[MAXN];
int p[MAXN];
std::vector<int> b;
int main() {
  int n, m;
  scanf("%d", &n);
  BinaryIndexedTree<long long> bit(n);
  BinaryIndexedTree<long long> bitAhead(n);
  long long free = 0;
  for (int i = 0; i < n; i++) {
    scanf("%d", &a[i]);
    indices[a[i]].push_back(i);
  }
  for (int i = 0; i < n; i++) {
    scanf("%d", &p[i]);
    if (p[i] > 0) {
      bit.add(i + 1, p[i]);
      bitAhead.add(i + 1, p[i]);
    } else {
      free += p[i];
    }
  }
  scanf("%d", &m);
  for (int i = 0; i < m; i++) {
    int next;
    scanf("%d", &next);
    b.push_back(next);
  }
  std::reverse(b.begin(), b.end());
  std::vector<State> prevState;
  int prevV = 0;
  prevState.push_back({0, 0});
  for (int i = 1; i <= n; i++) {
    if (!b.empty() && i == b.back()) {
      for (int i2 = prevV + 1; i2 <= i; i2++) {
        for (int index : indices[i2]) {
          if (p[index] > 0) {
            bitAhead.add(index + 1, -p[index]);
          }
        }
      }
      std::vector<State> nextState;
      long long currLoss = 0;
      for (int index : indices[i]) {
        auto it = std::upper_bound(
            prevState.begin(), prevState.end(), State({index, 0}),
            [](State s1, State s2) { return s1.pos < s2.pos; });
        if (it == prevState.begin()) {
          continue;
        }
        it--;
        long long reduce = (p[index] < 0 ? p[index] : 0);
        long long nextBit = bit.getSum(it->pos + 1, index);
        long long nextCost = it->cost + nextBit - reduce;
        if (!nextState.empty()) {
          long long cmpCost = nextState.back().cost +
                              bitAhead.getSum(nextState.back().pos + 1, index);
          if (nextCost >= cmpCost) {
            continue;
          }
        }
        nextState.push_back({index + 1, nextCost});
      }
      if (nextState.empty()) {
        printf("NO\n");
        return 0;
      }
      prevState = nextState;
      b.pop_back();
      for (int i2 = prevV + 1; i2 <= i; i2++) {
        for (auto index : indices[i2]) {
          if (p[index] > 0) {
            bit.add(index + 1, -p[index]);
          }
        }
      }
      prevV = i;
    }
  }
  long long best = 1e18;
  for (auto s : prevState) {
    long long next = s.cost + bit.getSum(s.pos + 1, n) + free;
    best = std::min(best, next);
  }
  printf("YES\n");
  printf("%lld\n", best);
  return 0;
}
