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

using ll = long long;
using ld = long double;

#define all(a) begin(a), end(a)
#define len(a) int((a).size())

#ifdef LOCAL
    #include "debug.h"
#else
    #define dbg(...)
    #define dprint(...)
    #define debug if constexpr (false)
    #define draw_tree(...)
    #define draw_array(...)
#endif // LOCAL

template<typename Fun>
struct y_combinator {
    const Fun fun;

    explicit y_combinator(const Fun&& fun) : fun(std::forward<const Fun>(fun)) {}

    template<typename... Args>
    auto operator()(Args&&... args) const {
        return fun(std::ref(*this), std::forward<Args>(args)...);
    }
};

vector<int> solve(int n, vector<int> a, int rot) {
    vector<int> last(2 * n, -1), mate(2 * n, -1);
    for (int i = 0; i < 2 * n; i++) {
        if (last[a[i]] == -1) {
            last[a[i]] = i;
        } else {
            mate[last[a[i]]] = i;
            mate[i] = last[a[i]];
        }
    }

    vector<int> ans(2 * n);

    y_combinator([&](auto dfs, int l, int r) -> void {
        if (r - l <= 1) {
            return;
        }

        int m = (l + r + rot) / 2;
        dfs(l, m);
        dfs(m, r);

        vector<int> f(r - m + 1);
        set<int> lims;
        for (int i = m; i < r; i++) {
            if (i < mate[i]) {
                f[i - m]++;
                f[min(r, mate[i]) - m]--;
            } else if (mate[i] < m) {
                lims.insert(i);
            }
        }

        for (int i = 1; i < len(f); i++) {
            f[i] += f[i - 1];
        }

        vector<int> psum(r - m + 1);
        for (int i = 0; i < r - m; i++) {
            psum[i + 1] = psum[i] + (f[i] == 0);
        }

        auto query = [&](int left, int right) {
            left = max(left, m);
            right = min(right, r);

            if (right <= left) {
                return 0;
            }
            return psum[right - m] - psum[left - m];
        };        

        set<pair<int, int>> open;
        for (int i = m - 1; i >= l; i--) {
            if (i < mate[i]) {
                if (mate[i] < m) {
                    open.erase({r, mate[i]});
                } else {
                    open.emplace(min(r, mate[i]), i);
                    lims.erase(mate[i]);
                }
            } else if (mate[i] < i) {
                open.emplace(r, i);
            }

            if (open.empty()) {
                continue;
            }

            auto [to, index] = *open.rbegin();
            int from = m;
            if (len(open) > 1) {
                from = next(open.rbegin())->first;
            }

            if (!lims.empty()) {
                to = min(to, *lims.begin());
            }

            ans[index] += query(from, to);
        }
    })(0, 2 * n);

    return ans;
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);

    int n;
    cin >> n;
    vector<int> a(2 * n);
    for (auto &x : a) {
        cin >> x;
        x--;
    }

    auto ans = solve(n, a, 0);
    dbg(ans);

    reverse(all(a));
    auto ans2 = solve(n, a, 1);
    for (int i = 0; i < len(ans); i++) {
        ans[i] += ans2.rbegin()[i];
    }

    for (auto x : ans) {
        cout << x + 1 << ' ';
    }
    cout << '\n';
}