#include <bits/stdc++.h>
#pragma GCC optimize("-O2")
using namespace std;
class UnionFind {
 public:
  vector<int> p, rank;
  UnionFind(int N) {
    rank.assign(N, 1);
    p.assign(N, 0);
    for (int i = 0; i < N; i++) p[i] = i;
  }
  int findSet(int i) { return (p[i] == i) ? i : (p[i] = findSet(p[i])); }
  bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
  void unionSet(int i, int j) {
    if (!isSameSet(i, j)) {
      int x = findSet(i), y = findSet(j);
      if (rank[x] > rank[y])
        p[y] = x, rank[x] += rank[y];
      else {
        p[x] = y;
        rank[y] += rank[x];
      }
    }
  }
};
class RMQ {
 public:
  struct node {
    int mn, mx, l, r;
  };
  vector<int> h;
  vector<node> st;
  bool is_intersection(int l, int r, int ll, int rr) {
    if (r < ll || rr < l) return 0;
    return 1;
  }
  RMQ(vector<int> a) {
    h = a;
    st.resize(4 * h.size());
    build(0, h.size() - 1);
  }
  void build(int l, int r, int k = 0) {
    st[k].l = l, st[k].r = r;
    if (l == r) {
      st[k].mx = st[k].mn = l;
      return;
    }
    build(l, (l + r) / 2, 2 * k + 1);
    build((l + r) / 2 + 1, r, 2 * k + 2);
    if (h[st[2 * k + 1].mn] <= h[st[2 * k + 2].mn])
      st[k].mn = st[2 * k + 1].mn;
    else
      st[k].mn = st[2 * k + 2].mn;
    if (h[st[2 * k + 1].mx] >= h[st[2 * k + 2].mx])
      st[k].mx = st[2 * k + 1].mx;
    else
      st[k].mx = st[2 * k + 2].mx;
  }
  int minquery(int l, int r, int k = 0) {
    if (l > r) return 1000000000;
    int ll = st[k].l, rr = st[k].r, mid = (ll + rr) / 2;
    if (ll >= l && rr <= r) return st[k].mn;
    int ans = l;
    if (!(r < ll || mid < l)) ans = minquery(l, r, 2 * k + 1);
    if (!(r < mid + 1 || rr < l)) {
      if (h[ans] > h[minquery(l, r, 2 * k + 2)])
        ans = minquery(l, r, 2 * k + 2);
    }
    return ans;
  }
  int maxquery(int l, int r, int k = 0) {
    if (l > r) return -1000000000;
    int ll = st[k].l, rr = st[k].r, mid = (ll + rr) / 2;
    if (ll >= l && rr <= r) return st[k].mx;
    int ans = l;
    if (!(r < ll || mid < l)) ans = maxquery(l, r, 2 * k + 1);
    if (!(r < mid + 1 || rr < l)) {
      if (h[ans] < h[maxquery(l, r, 2 * k + 2)])
        ans = maxquery(l, r, 2 * k + 2);
    }
    return ans;
  }
  void update(int id, int val, int k = 0) {
    int l = st[k].l, r = st[k].r, mid = (l + r) / 2;
    if (l == r) {
      h[l] = val;
      return;
    }
    if (id >= l && id <= mid) update(id, val, 2 * k + 1);
    if (mid + 1 <= id && id <= r) update(id, val, 2 * k + 2);
    if (h[st[2 * k + 1].mn] <= h[st[2 * k + 2].mn])
      st[k].mn = st[2 * k + 1].mn;
    else
      st[k].mn = st[2 * k + 2].mn;
    if (h[st[2 * k + 1].mx] >= h[st[2 * k + 2].mx])
      st[k].mx = st[2 * k + 1].mx;
    else
      st[k].mx = st[2 * k + 2].mx;
  }
};
class LAZY {
 public:
  struct node {
    int l, r, lazy = 0;
    long long int lazyval = 0;
    long long int sum = 0;
  };
  vector<node> st;
  vector<int> h;
  LAZY(vector<int> a) {
    h = a;
    st.resize(4 * h.size());
    cst(0, h.size() - 1);
  }
  int intersectiontype1(int l, int r, int ll, int rr) {
    if (r < ll || rr < l) return 0;
    return 1;
  }
  void cst(int l, int r, int k = 0) {
    st[k].l = l, st[k].r = r;
    if (l == r) {
      st[k].sum = h[l];
      return;
    }
    cst(l, (l + r) / 2, 2 * k + 1);
    cst((l + r) / 2 + 1, r, 2 * k + 2);
    st[k].sum = st[2 * k + 1].sum + st[2 * k + 2].sum;
  }
  void shift(int k) {
    st[k].sum = (st[k].r - st[k].l + 1) * st[k].lazyval;
    if (st[k].l != st[k].r) {
      st[2 * k + 1].lazyval = st[k].lazyval;
      st[2 * k + 2].lazyval = st[k].lazyval;
      st[2 * k + 1].lazy = st[2 * k + 1].lazy = 1;
      st[2 * k + 2].lazy = st[2 * k + 2].lazy = 1;
    }
    st[k].lazyval = 0;
    st[k].lazy = 0;
  }
  long long int query(int l, int r, int k = 0) {
    if (st[k].lazy != 0) shift(k);
    int ll = st[k].l, rr = st[k].r, mid = (ll + rr) / 2;
    if (ll >= l && rr <= r) return st[k].sum;
    long long int ans = 0;
    if (intersectiontype1(ll, mid, l, r) == 1) ans = query(l, r, 2 * k + 1);
    if (intersectiontype1(1 + mid, rr, l, r) == 1)
      ans += query(l, r, 2 * k + 2);
    return ans;
  }
  void update(int l, int r, long long int x, int k = 0) {
    if (l > r) return;
    int ll = st[k].l, rr = st[k].r, mid = (ll + rr) / 2;
    if (ll >= l && rr <= r) {
      st[k].lazyval = x;
      st[k].lazy = 1;
      return;
    }
    if (st[k].lazy != 0) shift(k);
    if (st[k].l == st[k].r) return;
    if (intersectiontype1(ll, mid, l, r) == 1) update(l, r, x, 2 * k + 1);
    if (intersectiontype1(mid + 1, rr, l, r) == 1) update(l, r, x, 2 * k + 2);
    if (st[2 * k + 1].lazy != 0) shift(2 * k + 1);
    if (st[2 * k + 2].lazy != 0) shift(2 * k + 2);
    st[k].sum = st[2 * k + 1].sum + st[2 * k + 2].sum;
  }
  int lower_bound(int l, int r, int val) {
    while (l != r) {
      int mid = (l + r) / 2;
      if (query(mid, mid) >= val)
        r = mid;
      else {
        l = mid + 1;
        if (mid + 1 < h.size())
          if (query(mid + 1, mid + 1) > val) {
            l = mid;
            break;
          }
      }
    }
    return l;
  }
};
class span {
 public:
  vector<int> a;
  span(){};
  vector<int> max_left_border_without_equality() {
    int n = a.size();
    vector<int> ta, al(n);
    for (long long int i = 0; i < n; i++) {
      if (ta.size() == 0) {
        ta.push_back(i);
        al[i] = i;
      } else {
        while (a[i] > a[ta[ta.size() - 1]]) {
          ta.pop_back();
          if (ta.size() == 0) break;
        }
        if (ta.size() == 0) {
          ta.push_back(i);
          al[i] = 0;
        } else {
          al[i] = ta[ta.size() - 1] + 1;
          ta.push_back(i);
        }
      }
    }
    return al;
  }
  vector<int> max_left_border_with_equality() {
    int n = a.size();
    vector<int> ta, al(n);
    for (long long int i = 0; i < n; i++) {
      if (ta.size() == 0) {
        ta.push_back(i);
        al[i] = i;
      } else {
        while (a[i] >= a[ta[ta.size() - 1]]) {
          ta.pop_back();
          if (ta.size() == 0) break;
        }
        if (ta.size() == 0) {
          ta.push_back(i);
          al[i] = 0;
        } else {
          al[i] = ta[ta.size() - 1] + 1;
          ta.push_back(i);
        }
      }
    }
    return al;
  }
  vector<int> min_left_border_without_equality() {
    int n = a.size();
    vector<int> ta, al(n);
    for (long long int i = 0; i < n; i++) {
      if (ta.size() == 0) {
        ta.push_back(i);
        al[i] = i;
      } else {
        while (a[i] < a[ta[ta.size() - 1]]) {
          ta.pop_back();
          if (ta.size() == 0) break;
        }
        if (ta.size() == 0) {
          ta.push_back(i);
          al[i] = 0;
        } else {
          al[i] = ta[ta.size() - 1] + 1;
          ta.push_back(i);
        }
      }
    }
    return al;
  }
  vector<int> min_left_border_with_equality() {
    int n = a.size();
    vector<int> ta, al(n);
    for (long long int i = 0; i < n; i++) {
      if (ta.size() == 0) {
        ta.push_back(i);
        al[i] = i;
      } else {
        while (a[i] <= a[ta[ta.size() - 1]]) {
          ta.pop_back();
          if (ta.size() == 0) break;
        }
        if (ta.size() == 0) {
          ta.push_back(i);
          al[i] = 0;
        } else {
          al[i] = ta[ta.size() - 1] + 1;
          ta.push_back(i);
        }
      }
    }
    return al;
  }
  vector<int> max_right_border_without_equality() {
    int n = a.size();
    reverse(a.begin(), a.end());
    vector<int> ans = max_left_border_without_equality();
    reverse(ans.begin(), ans.end());
    for (long long int i = 0; i < n; i++) ans[i] = n - 1 - ans[i];
    reverse(a.begin(), a.end());
    return ans;
  }
  vector<int> max_right_border_with_equality() {
    int n = a.size();
    reverse(a.begin(), a.end());
    vector<int> ans = max_left_border_with_equality();
    reverse(ans.begin(), ans.end());
    for (long long int i = 0; i < n; i++) ans[i] = n - 1 - ans[i];
    reverse(a.begin(), a.end());
    return ans;
  }
  vector<int> min_right_border_without_equality() {
    int n = a.size();
    reverse(a.begin(), a.end());
    vector<int> ans = min_left_border_without_equality();
    reverse(ans.begin(), ans.end());
    for (long long int i = 0; i < n; i++) ans[i] = n - 1 - ans[i];
    reverse(a.begin(), a.end());
    return ans;
  }
  vector<int> min_right_border_with_equality() {
    int n = a.size();
    reverse(a.begin(), a.end());
    vector<int> ans = min_left_border_with_equality();
    reverse(ans.begin(), ans.end());
    for (long long int i = 0; i < n; i++) ans[i] = n - 1 - ans[i];
    reverse(a.begin(), a.end());
    return ans;
  }
};
class merge_sort_tree {
 public:
  long long int cnt(long long int x, vector<int> &arr) {
    long long int n = arr.size();
    vector<int>::iterator low, high;
    low = lower_bound(arr.begin(), arr.end(), x);
    if (low == (arr.end()) || *low != x) return 0;
    high = upper_bound(low, arr.end(), x);
    return high - low;
  }
  long long int get_last_smaller(vector<int> &v, int x) {
    long long int first = 0, last = v.size() - 1;
    while (first <= last) {
      long long int mid = (first + last) / 2;
      if (v[mid] >= x)
        last = mid - 1;
      else
        first = mid + 1;
    }
    return first - 1 < 0 ? -1 : first - 1;
  }
  struct node {
    int l, r;
    vector<int> arr;
  };
  vector<int> a;
  vector<node> st;
  merge_sort_tree(vector<int> b) {
    st.resize(4 * b.size());
    a = b;
    build(0, b.size() - 1);
  }
  void build(int l, int r, int k = 0) {
    st[k].l = l, st[k].r = r;
    for (int i = l; i < r + 1; i++) st[k].arr.push_back(a[i]);
    sort(st[k].arr.begin(), st[k].arr.end());
    if (l == r) return;
    build(l, (l + r) / 2, 2 * k + 1);
    build((l + r) / 2 + 1, r, 2 * k + 2);
  }
  bool intersection(int l, int r, int ll, int rr) {
    if (ll > r || l > rr) return 0;
    return 1;
  }
  long long int count_val_in_range(int l, int r, int t, int k = 0) {
    if (l > r) return 0;
    int ll = st[k].l, rr = st[k].r, mid = (ll + rr) / 2;
    if (ll >= l && rr <= r) return cnt(t, st[k].arr);
    long long int ans = 0;
    if (intersection(l, r, ll, mid) == 1)
      ans += count_val_in_range(l, r, t, 2 * k + 1);
    if (intersection(l, r, mid + 1, rr) == 1)
      ans += count_val_in_range(l, r, t, 2 * k + 2);
    return ans;
  }
  long long int count_vals_less_than_given_val(int l, int r, int t, int k,
                                               vector<node> &st) {
    if (l > r) return 0;
    int ll = st[k].l, rr = st[k].r, mid = (ll + rr) / 2;
    if (ll >= l && rr <= r) return get_last_smaller(st[k].arr, t) + 1;
    long long int ans = 0;
    if (intersection(l, r, ll, mid) == 1)
      ans += count_vals_less_than_given_val(l, r, t, 2 * k + 1, st);
    if (intersection(l, r, mid + 1, rr) == 1)
      ans += count_vals_less_than_given_val(l, r, t, 2 * k + 2, st);
    return ans;
  }
};
void DEBUG_ARR(vector<int> a) {
  for (long long int i = 0; i < a.size(); i++) cout << a[i] << " ";
  cout << "\n";
}
long long int tmod(long long int x, long long int m) { return (x % m + m) % m; }
long long int power(long long int x, long long int y) {
  long long int res = 1;
  while (y > 0) {
    if (y & 1) res = (res * x) % 1000000007;
    y = y >> 1;
    x = (x * x) % 1000000007;
  }
  if (res < 0) res += 1000000007;
  return res;
}
long long int modInverse(long long int a, long long int m) {
  long long int m0 = m;
  long long int y = 0, x = 1;
  if (m == 1) return 0;
  while (a > 1) {
    long long int q = a / m;
    long long int t = m;
    m = a % m, a = t;
    t = y;
    y = x - q * y;
    x = t;
  }
  if (x < 0) x += m0;
  return x;
}
int cnt[200001];
int smallest_correct_prefix(int l, int r, int ccnt[], int knight_color[],
                            int m) {
  int mid = (l + r) / 2;
  for (long long int i = 1; i < m + 1; i++) cnt[i] = 0;
  for (long long int i = 0; i < mid + 1; i++) cnt[knight_color[i]]++;
  if (l == r) return l;
  for (long long int i = 1; i < m + 1; i++)
    if (cnt[i] < ccnt[i])
      return smallest_correct_prefix(mid + 1, r, ccnt, knight_color, m);
  return smallest_correct_prefix(l, mid, ccnt, knight_color, m);
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  int n, m;
  cin >> n >> m;
  int knight_color[n];
  for (long long int i = 0; i < n; i++) cin >> knight_color[i];
  int ccnt[m + 1];
  for (long long int i = 0; i < m; i++) cin >> ccnt[i + 1];
  int sum = 0;
  for (long long int i = 1; i < m + 1; i++) sum += ccnt[i];
  int l = 0, r;
  int ans = 1000000000;
  for (long long int i = 0; i < n; i++) cnt[knight_color[i]]++;
  for (long long int i = 1; i < m + 1; i++) {
    if (cnt[i] < ccnt[i]) {
      cout << -1;
      return 0;
    }
  }
  r = smallest_correct_prefix(0, n - 1, ccnt, knight_color, m);
  int bada_sum = 0;
  for (long long int i = 1; i < m + 1; i++) bada_sum += cnt[i];
  while (r != n) {
    while (cnt[knight_color[l]] >= ccnt[knight_color[l]] + 1) {
      cnt[knight_color[l]]--;
      bada_sum--;
      l++;
    }
    ans = min(ans, bada_sum - sum);
    r++;
    if (r == n) break;
    cnt[knight_color[r]]++;
    bada_sum++;
  }
  cout << ans;
  return 0;
}
