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

struct DSU {
    vector<int> parent, sz;
    vector<bool> active;
    DSU(int n) {
        parent.resize(n + 2);
        sz.resize(n + 2, 0);
        active.resize(n + 2, false);
        for (int i = 0; i <= n + 1; ++i) parent[i] = i;
    }
    int find(int x) {
        return parent[x] == x ? x : parent[x] = find(parent[x]);
    }
    void unite(int a, int b, int &currentMax) {
        a = find(a); b = find(b);
        if (a == b) return;
        if (sz[a] < sz[b]) swap(a, b);
        parent[b] = a;
        sz[a] += sz[b];
        currentMax = max(currentMax, sz[a]);
    }
    void activate(int i, int &currentMax) {
        active[i] = true;
        sz[i] = 1;
        currentMax = max(currentMax, 1);
    }
};

int main() {
    ios::sync_with_stdio(false); cin.tie(nullptr);
    int n, q;
    if (!(cin >> n >> q)) return 0;
    vector<pair<int, int>> a(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i].first;
        a[i].second = i + 1;
    }
    vector<pair<int, int>> queries(q);
    for (int i = 0; i < q; ++i) {
        cin >> queries[i].first;
        queries[i].second = i;
    }
    sort(a.begin(), a.end());
    sort(queries.begin(), queries.end());

    DSU dsu(n);
    vector<int> results(q);
    int currentMax = 0;
    int ptr = 0;

    for (int i = 0; i < q; ++i) {
        int limit = queries[i].first;
        int idx = queries[i].second;
        while (ptr < n && a[ptr].first <= limit) {
            int pos = a[ptr].second;
            dsu.activate(pos, currentMax);
            if (pos > 1 && dsu.active[pos - 1]) dsu.unite(pos, pos - 1, currentMax);
            if (pos < n && dsu.active[pos + 1]) dsu.unite(pos, pos + 1, currentMax);
            ptr++;
        }
        results[idx] = currentMax;
    }
    for (int res : results) cout << res << "\n";
    return 0;
}

// Pseudocode logic representation for clarity
#include <bits/stdc++.h>
using namespace std;

const int MAXN = 100005;
int n, q;
int a[MAXN];
vector<int> vals; // Mảng lưu các giá trị phân loại
vector<int> pos[MAXN]; // Danh sách vị trí cho mỗi giá trị
int tree[4 * MAXN]; // Segment tree lưu độ dài đoạn dài nhất
int pref[MAXN]; // Prefix sum để đếm số phần tử <= X

void build(int node, int l, int r) {
    if (l == r) {
        // Logic tính toán tại lá
        return;
    }
    int mid = (l + r) / 2;
    build(2 * node, l, mid);
    build(2 * node + 1, mid + 1, r);
    // Logic gộp kết quả
}

int query(int node, int l, int r, int ql, int qr) {
    if (ql > r || qr < l) return 0;
    if (ql <= l && r <= qr) return tree[node];
    int mid = (l + r) / 2;
    return query(2 * node, l, mid, ql, qr) + query(2 * node + 1, mid + 1, r, ql, qr);
}

int main() {
    // Đọc dữ liệu
    // Lấy mảng a và sắp xếp để lấy các giá trị phân loại (compression)
    // Xây dựng cây phân đoạn dựa trên các vị trí
    // Với mỗi truy vấn V, tìm chỉ số trong mảng giá trị phân loại
    // Truy vấn cây phân đoạn để tìm kết quả
    return 0;
}

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

int main() {
    // Code dưới đây chỉ minh họa logic tính toán cho 1 giá trị V c cụ thể
    // Để xử lý Q truy vấn, ta có thể dùng Offline + Suy nghĩ về Segment Tree hoặc DSU.
    // Tuy nhiên, Segment Tree kết hợp với Monotonic Stack để tìm Left/Right boundaries là 1 cách khác.

    int n, q;
    cin >> n >> q;
    vector<int> a(n + 1);
    for(int i = 1; i <= n; i++) cin >> a[i];

    // Logic cho Offline:
    // Sắp xếp (a[i], i) tăng dần.
    // Sắp xếp truy vấn tăng dần.
    // Sử dụng Segment Tree hoặc DSU để kích hoạt các phần tử.

    // Logic cho Online (không khuyến khích nếu Q lớn):
    // Với mỗi truy vấn V, tạo mảng boolean valid[n].
    // for i=1..n: if a[i] <= V valid[i] = true else false.
    // Duyệt mảng valid tìm đoạn dài nhất chứa toàn true.
    // Độ phức tạp O(N*Q) -> Chậm.

    return 0;
}