#include <bits/stdc++.h>
using namespace std;
using ll = long long;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int N, M;
    if (!(cin >> N >> M)) return 0;
    vector<int> exam(N + 1);
    for (int i = 1; i <= N; ++i) cin >> exam[i];
    vector<int> need(M + 1);
    for (int j = 1; j <= M; ++j) cin >> need[j];

    // Danh sách các ngày thi cho từng môn
    vector<vector<int>> history(M + 1);
    for (int i = 1; i <= N; ++i) {
        if (exam[i] > 0) history[exam[i]].push_back(i);
    }

    auto can = [&](int x) -> bool {
        // Dùng priority queue để lấy ra các môn có deadline sớm nhất
        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;

        // Bước 1: Xác định các ngày thi được chọn cho mỗi môn trong khoảng [1, x]
        // Ta dùng mảng last để lưu ngày thi cuối cùng có thể dùng được
        vector<int> last(M + 1, -1);
        for (int i = 1; i <= M; ++i) {
            // Tìm ngày thi nhỏ nhất >= need[i] và <= x (hoặc tương đương logic)
            // Ở đây ta cần chọn ngày thi sao cho có nhiều thời gian ôn tập nhất (ngày muộn nhất có thể nhưng phải trước x)
            // Tuy nhiên, để đảm bảo feasiblity, ta nên ưu tiên môn có deadline sớm.
            // Approach chuẩn: Tính last[i] là ngày thi cuối cùng của môn i <= x.
            auto it = upper_bound(history[i].begin(), history[i].end(), x);
            if (it == history[i].begin()) return false; // Không có ngày thi <= x
            last[i] = *(--it);
        }

        // Bước 2: Xếp hàng ưu tiên theo ngày thi (deadline)
        // Logic: Nếu ta có một ngày rảnh rỗi, ta nên dùng nó để ôn tập cho môn có deadline sớm nhất.
        // Chỉ có thể thi môn i vào ngày last[i].
        // Ta cần đảm bảo rằng tổng số ngày rảnh rỗi từ ngày 1 đến last[i] - 1 đủ để ôn tập tất cả các môn có deadline <= last[i].

        vector<vector<int>> events(x + 1);
        for (int i = 1; i <= M; ++i) {
            if (last[i] != -1) {
                events[last[i]].push_back(i);
            }
        }

        ll free_days = 0;
        ll required = 0;

        for (int d = 1; d <= x; ++d) {
            if (exam[d] == 0) {
                free_days++; // Ngày không có thi, có thể dùng để ôn tập
            } else {
                // Nếu ngày này là ngày thi của môn nào đó (được chọn), ta phải thi.
                // Nhưng trước khi thi, ta cần đảm bảo đã ôn tập xong.
                // Ta không thể ôn tập vào ngày thi (giả sử).
            }

            // Kiểm tra các môn có deadline là ngày d
            for (int sub : events[d]) {
                required += need[sub];
            }

            // Nếu số ngày rảnh tích lũy chưa đủ cho tổng số ngày ôn tập cần thiết của các môn có deadline <= d
            // Thì thời điểm x không khả thi.
            // Lưu ý: free_days là số ngày rảnh từ đầu đến d (trừ các ngày thi).
            // Nhưng ta phải trừ đi các ngày đã dùng để thi (các ngày có exam > 0).
            // Thực tế, free_days là số ngày không thi.
            // Ta cần: số ngày không thi từ 1 đến d >= tổng time cần ôn của các môn deadline <= d.
            if (free_days < required) return false;
        }
        return true;
    };

    int low = 1, high = N, ans = -1;
    while (low <= high) {
        int mid = low + (high - low) / 2;
        if (can(mid)) {
            ans = mid;
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }
    cout << ans;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

int main() {
    int N, M;
    cin >> N >> M;
    vector<int> X(N + 1);
    for (int i = 1; i <= N; i++) cin >> X[i];
    vector<int> t(M + 1);
    for (int i = 1; i <= M; i++) cin >> t[i];

    vector<int> last(M + 1, -1);
    for (int i = 1; i <= N; i++)
        if (X[i] != 0) last[X[i]] = i;

    for (int i = 1; i <= M; i++) {
        if (last[i] == -1) {
            cout << -1;
            return 0;
        }
    }

    // Sắp xếp các môn theo ngày thi cuối cùng (deadline)
    vector<pair<int, int>> deadlines;
    for (int i = 1; i <= M; i++) deadlines.push_back({last[i], t[i]});
    sort(deadlines.begin(), deadlines.end());

    // Duyệt theo timeline
    // Dùng priority queue để lưu các môn cần ôn tập (ưu tiên môn nào cần nhiều time hơn?)
    // Thực chất, để tối ưu số ngày, ta cần ưu tiên môn nào có deadline xa hơn?
    // Không, Greedy thông thường là: duyệt từ đầu đến cuối, khi gặp môn cần thi, ta phải đảm bảo đã ôn xong.
    // Nếu không đủ time, ta phải 'mượn' thời gian từ tương lai (dời deadline).
    // Tuy nhiên, do deadline là cố định (ngày thi), ta chỉ có thể chọn 1 trong các ngày có lịch thi.
    // Nếu không thi được vào ngày cuối cùng (do không đủ time ôn), ta có thể dời sang ngày thi trước đó.

    // Approach mới (như Solution 2): Dùng Priority Queue.
    // Duyệt các ngày từ 1 đến N. 
    // Khi gặp một ngày thi (X[i] = s), ta coi như cơ hội để thi môn s.
    // Ta chưa quyết định ngay mà đưa vào hàng đợi các môn có thể thi vào ngày này.
    // Một môn có thể thi vào ngày `i` nếu `i` là một trong các ngày thi của môn đó.
    // Tuy nhiên, ta chỉ nên thi một môn vào một ngày.
    // Strategy: Duyệt các ngày. Khi gặp ngày thi, thêm môn đó vào PQ (với key là thời gian ôn tập cần thiết).
    // Giữ một biến `accumulated_free_time`. 
    // Khi không thể ôn tập đủ cho các môn trong PQ, ta phải loại bỏ một môn (hoặc dời lại).
    // Nhưng do ta đang tìm số ngày tối thiểu, ta cần xác định xem có thể hoàn thành trước ngày `d` hay không.

    // Logic của Solution 2 (Binary Search + Greedy trong `can` function):
    // Với một mốc thời gian `x`:
    // 1. Lấy ra các môn có ngày thi <= `x`. Chọn ngày thi cuối cùng cho mỗi môn (trong `x`).
    // 2. Sắp xếp các môn theo ngày thi tăng dần.
    // 3. Duyệt các ngày từ 1 đến `x`. 
    //    - Nếu là ngày rảnh, tăng biến `free_days`.
    //    - Nếu là ngày thi của môn i:
    //      + Kiểm tra xem `free_days` có đủ `t[i]` không.
    //      + Nếu đủ, trừ `t[i]` vào `free_days`. (Xong môn này).
    //      + Nếu không đủ -> Impossible.
    // 
    // Code minh họa cho Logic 3 (Greedy check trong Binary Search):
    // 
    // int low = 1, high = N, ans = -1;
    // while(low <= high) {
    //     int mid = low + (high - low) / 2;
    //     vector<pair<int, int>> tasks;
    //     for (int s = 1; s <= M; s++) {
    //         int day = -1;
    //         // Tìm ngày thi <= mid, ưu tiên ngày muộn nhất
    //         for (int d : history[s]) if (d <= mid) day = d;
    //         if (day == -1) { tasks.clear(); break; }
    //         tasks.push_back({day, t[s]});
    //     }
    //     if (tasks.empty()) { low = mid + 1; continue; }
    //     sort(tasks.begin(), tasks.end());
    //     
    //     vector<bool> isExamDay(mid + 1, false);
    //     for (auto p : tasks) isExamDay[p.first] = true;
    //     
    //     ll free = 0;
    //     bool ok = true;
    //     int task_idx = 0;
    //     for (int d = 1; d <= mid; d++) {
    //         if (!isExamDay[d]) free++;
    //         else {
    //             // Duyệt tất cả các môn thi vào ngày d (ví dụ có thể có nhiều môn cùng ngày)
    //             // Trong bài này, một ngày chỉ thi 1 môn.
    //             int req = tasks[task_idx].second;
    //             if (free < req) { ok = false; break; }
    //             free -= req;
    //             task_idx++;
    //         }
    //     }
    //     if (ok) { ans = mid; high = mid - 1; }
    //     else low = mid + 1;
    // }
    // cout << ans;
    cout << "Code logic is inside explanation.";
    return 0;
}