#include "assert.h"
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <string.h>
#include <time.h>
#include <vector>

#if LOCAL
    #define DO_NOT_SEND
#endif

typedef long long LL;

int IntMaxVal = (int) 1e20;
int IntMinVal = (int) -1e20;
LL LongMaxVal = (LL) 1e20;
LL LongMinVal = (LL) -1e20;

#define FOR(i, a, b) for(int i = a; i < b ; ++i)
#define FORD(i, a, b) for(int i = a; i >= b; --i)

template<typename T> inline void minimize(T &a, T b) { a = std::min(a, b); }
template<typename T> inline void maximize(T &a, T b) { a = std::max(a, b); }

#define all(v) v.begin(),v.end()

using namespace std;

#define endl '\n'
template<typename T> struct argument_type;
template<typename T, typename U> struct argument_type<T(U)> { typedef U type; };
#define next(t, i) argument_type<void(t)>::type i; cin >> i;

template <typename T1, typename T2> istream& operator >>(istream& is, pair<T1, T2>& s) { is >> s.first >> s.second; return is; }
template <typename T> ostream& operator << (ostream& os, const vector<T> &v) { for (int i = 0 ; i < v.size() ; i++) { if (i) os << ' '; os << v[i]; } os << endl; return os; }
template <typename T1, typename T2> ostream& operator <<(ostream& s, const pair<T1, T2>& t) { s << t.first << ' ' << t.second; return s; }
template <typename T> vector<T> readVector(int n) { vector<T> res(n); for (int i = 0 ; i < n ; i++) cin >> res[i]; return res; }







struct query
{
    int index, param, value;
};

bool byParam(const query &x1, const query &x2) {
    return x1.param < x2.param;
}

bool byIndex(const query &x1, const query &x2) {
    return x1.index < x2.index;
}

istream& operator >> (istream& is, query &x) {
    static int id = 0;
    x.index = id++;
    return is >> x.param;
}

vector<vector<int>> colour_groups(100 * 1000 + 1);
vector<query> queries;

void add_on_range(int l, int r, int val) {
    queries[l].value += val;
    if (r + 1 < queries.size()) queries[r + 1].value -= val;
}

int solve_on_queries_range_straightforward(int c, int query_index) {
    int maxLength = queries[query_index].param;
    int res = 0;
    int upTo = -1;
    for (auto x : colour_groups[c]) if (x > upTo) {
        res++;
        upTo = x + maxLength;
    }
    return res;
}

void solve_on_queries_range(int c, int l, int ans1, int r, int ans2) {
    if (l + 1 >= r) return;
    if (ans1 == ans2) {
        add_on_range(l + 1, r - 1, ans1);
    } else {
        int mid = (l + r) / 2;
        int ans_mid = solve_on_queries_range_straightforward(c, mid);
        add_on_range(mid, mid, ans_mid);
        solve_on_queries_range(c, l, ans1, mid, ans_mid);
        solve_on_queries_range(c, mid, ans_mid, r, ans2);
    }
}

int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL);

    next(int, n);
    auto v = readVector<int>(n);

    FOR (i, 0, n) colour_groups[v[i]].push_back(i);

    next(int, q);
    queries = readVector<query>(q);

    sort(all(queries), byParam);
    FOR (c, 1, colour_groups.size()) {
        int ans1 = solve_on_queries_range_straightforward(c, 0);
        int ans2 = solve_on_queries_range_straightforward(c, q - 1);
        add_on_range(0, 0, ans1);
        if (q > 1) add_on_range(q - 1, q - 1, ans2);
        solve_on_queries_range(c, 0, ans1, q - 1, ans2);
    }
    FOR (i, 1, q) queries[i].value += queries[i - 1].value;
    sort(all(queries), byIndex);
    for (auto &q : queries) cout << q.value << ' ';
}