#include <bits/stdc++.h>
using namespace std;
#include <atcoder/all>
using namespace atcoder;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using Graph = vector<vector<ll>>;
using vi = vector<int>;
using vl = vector<long>;
using vll = vector<long long>;
using vvi = vector<vi>;
using vvl = vector<vl>;
using vvll = vector<vll>;
using vs = vector<string>;
using vc = vector<char>;
using vvc = vector<vc>;
using pll = pair<long long, long long>;
using vpll = vector<pll>;
using mint = modint1000000007;
const long double EPS = 1e-18;
const long long INF = 1e18;
const long double PI = acos(-1.0L);
#define reps(i, a, n) for (ll i = (a); i < (ll)(n); i++)
#define rep(i, n) for (ll i = (0); i < (ll)(n); i++)
#define rrep(i, n) for (ll i = (1); i < (ll)(n + 1); i++)
#define repd(i, n) for (ll i = n - 1; i >= 0; i--)
#define rrepd(i, n) for (ll i = n; i >= 1; i--)
#define ALL(n) begin(n), end(n)
#define IN(a, x, b) (a <= x && x < b)
#define INIT                          \
    std::ios::sync_with_stdio(false); \
    std::cin.tie(0);
template <class T>
inline T CHMAX(T& a, const T b) {
    return a = (a < b) ? b : a;
}
template <class T>
inline T CHMIN(T& a, const T b) {
    return a = (a > b) ? b : a;
}
// --- Lazy Segtree に載せる代数構造の定義 ---
struct Node {
    ll sum;
    ll size;
    ll max_val;
};

using F = ll;
const F ID = -1;

// 二つの区間をマージする操作
Node op(Node a, Node b) {
    return {a.sum + b.sum, a.size + b.size, max(a.max_val, b.max_val)};
}

// 単位元
Node e() { return {0, 0, -1}; }

// 区間に作用素を適用（代入）する操作
Node mapping(F f, Node x) {
    if (f == ID) return x;
    return {f * x.size, x.size, f};
}

// 作用素の合成（f(g(x))）
F composition(F f, F g) { return (f == ID ? g : f); }

// 作用素の恒等写像 identity function
F id() { return ID; }
// ---------------------------------------------

int main() {
    INIT;
    ll N;
    cin >> N;
    vvll pos(N + 2, vll(1, 0));
    rrep(i, N) {
        ll a;
        cin >> a;
        if (a <= N + 1) {
            pos[a].push_back(i);
        }
    }
    rep(i, N + 2) { pos[i].push_back(N + 1); }
    vll S(N + 2, 0);
    S[0] = N * (N + 1) / 2;

    vector<Node> inn(N, {0, 1, 0});
    lazy_segtree<Node, op, e, F, mapping, composition, id> seg(inn);

    rep(i, pos[0].size() - 1) {
        ll l = max(1ll, pos[0][i]);
        ll r = pos[0][i + 1] - 1;
        if (l <= r) {
            seg.apply(l - 1, r, pos[0][i]);
        }
    }
    S[1] = seg.all_prod().sum;

    rrep(k, N) {
        rep(i, pos[k].size() - 1) {
            ll l = max(1ll, pos[k][i]);
            ll r = pos[k][i + 1] - 1;
            if (l <= r) {
                ll idx = seg.max_right(
                    l - 1, [&](Node x) { return x.max_val <= pos[k][i]; });
                if (idx < r) {
                    seg.apply(idx, r, pos[k][i]);
                }
            }
        }
        S[k + 1] = seg.all_prod().sum;
    }
    rep(i, N + 1) { cout << S[i] - S[i + 1] << "\n"; }

    return 0;
}