#include "bits/stdc++.h"
#define rep(i, a, n) for (auto i = a; i <= (n); ++i)
#define revrep(i, a, n) for (auto i = n; i >= (a); --i)
#define all(a) a.begin(), a.end()
#define sz(a) (int)(a).size()
template<class T> inline bool chmax(T &a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, T b) { if (b < a) { a = b; return 1; } return 0; }
using namespace std;

template<class A, class B> string to_string(const pair<A, B> &p);
template<class A, class B, class C> string to_string(const tuple<A, B, C> &p);
template<class A, class B, class C, class D> string to_string(const tuple<A, B, C, D> &p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string) s); }
string to_string(char c) { return "'" + string(1, c) + "'"; }
string to_string(bool x) { return x ? "true" : "false"; }
template<class A, class T = typename A::value_type> string to_string(const A &v) {
    bool first = 1;
    string res = "{";
    for (const auto &x: v) {
        if (!first) res += ", ";
        first = 0;
        res += to_string(x);
    }
    res += "}";
    return res;
}
template<class A, class B> string to_string(const pair<A, B> &p) {
    return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template<class A, class B, class C> string to_string(const tuple<A, B, C> &p) {
    return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template<class A, class B, class C, class D> string to_string(const tuple<A, B, C, D> &p) {
    return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}

void debug_out() { cerr << endl; }
template<class H, class... T> void debug_out(const H& h, const T&... t) {
    cerr << " " << to_string(h);
    debug_out(t...);
}
#ifndef ONLINE_JUDGE
    #define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
    #define debug(...) if (0) puts("No effect.")
#endif

using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;

const int inf = 0x3f3f3f3f;

struct Tag {
	int val;
	Tag(int val = inf) : val(val) {}
	friend bool operator ==(Tag a, Tag b) { return a.val == b.val; }
	friend void tag_apply(Tag &cur, int l, int r, const Tag &x) {
		if (x.val != inf) cur = x;
	}
};

struct Info {
	int val;
	int id;
	Info(int val = inf, int id = -1): val(val), id(id) {}
	friend Info operator +(const Info &a, const Info &b) {
		return a.val < b.val ? a : b;
	}
	friend void info_apply(Info &cur, int l, int r, const Tag &x) {
		if (x.val != inf) cur.val = x.val;
	}
};

/**
 * Author: Yuhao Yao
 * Date: 24-01-07
 * Description: Segment tree with lazy propogation.
 * Usage: Always define functions \textbf{info\_apply} and \textbf{tag\_apply} to tell segment tree how you apply modification.
 *  Combine is set as plus so if you just let T be numerical type then you have range sum in the info and as range query result. To have something different, say rangeMin, define a struct with constructer and + operation.
 * Time: O(\log N) per operation.
 * Status: tested on https://codeforces.com/gym/103371/problem/M.
 */
template<class Info, class Tag>
class LazySegTree {
	#define ls i * 2
	#define rs i * 2 + 1

	int n;
	vector<Info> info;
	vector<Tag> tag;
public:
	LazySegTree(int n): n(n) {
		assert(n > 0);
		info.resize(4 << __lg(n));
		tag.resize(4 << __lg(n));
	}
	LazySegTree(const vector<Info> &init): LazySegTree(sz(init)) {
		auto build = [&](auto &dfs, int i, int l, int r) {
			if (l == r) {
				info[i] = init[l];
				return;
			}
			int mid = (l + r) >> 1;
			dfs(dfs, ls, l, mid);
			dfs(dfs, rs, mid + 1, r);
			pull(i);
		};
		build(build, 1, 0, n - 1);
	}
private:
	void pull(int i) { info[i] = info[ls] + info[rs]; }

	template<class... T>
	void apply(int i, int l, int r, const T&... val) {
		info_apply(info[i], l, r, val...);
		tag_apply(tag[i], l, r, val...);
	}

	void push(int i, int l, int r) {
		if (tag[i] == Tag{}) return;
		int mid = (l + r) >> 1;
		apply(ls, l, mid, tag[i]);
		apply(rs, mid + 1, r, tag[i]);
		tag[i] = {};
	}
public:
	template<class... T>
	void range_apply(int ql, int qr, const T&... val) {
		auto dfs = [&](auto &dfs, int i, int l, int r) {
			if (qr < l || r < ql) return;
			if (ql <= l && r <= qr) {
				apply(i, l, r, val...);
				return;
			}
			push(i, l, r);
			int mid = (l + r) >> 1;
			dfs(dfs, ls, l, mid);
			dfs(dfs, rs, mid + 1, r);
			pull(i);
		};
		dfs(dfs, 1, 0, n - 1);
	}

	Info range_ask(int ql, int qr) {
		Info res{};
		auto dfs = [&](auto &dfs, int i, int l, int r) {
			if (qr < l || r < ql) return;
			if (ql <= l && r <= qr) {
				res = res + info[i];
				return;
			}
			push(i, l, r);
			int mid = (l + r) >> 1;
			dfs(dfs, ls, l, mid);
			dfs(dfs, rs, mid + 1, r);
		};
		dfs(dfs, 1, 0, n - 1);
		return res;
	}

	int find_first(int ql, int qr, function<bool(const Info&, int, int)> func) {
		auto dfs = [&](auto &dfs, int i, int l, int r) {
			if (qr < l || r < ql || (ql <= l && r <= qr && func(info[i], l, r) == 0)) return -1;
			if (l == r) return l;

			push(i, l, r);
			int mid = (l + r) >> 1;
			int res = dfs(dfs, ls, l, mid);
			if (res != -1) return res;
			else return dfs(dfs, rs, mid + 1, r);
		};
		return dfs(dfs, 1, 0, n - 1);
	};

	int find_last(int ql, int qr, function<bool(const Info&, int, int)> func) {
		auto dfs = [&](auto &dfs, int i, int l, int r) {
			if (qr < l || r < ql || (ql <= l && r <= qr && func(info[i], l, r) == 0)) return -1;
			if (l == r) return l;

			push(i, l, r);
			int mid = (l + r) >> 1;
			int res = dfs(dfs, rs, mid + 1, r);
			if (res != -1) return res;
			else return dfs(dfs, ls, l, mid);
		};
		return dfs(dfs, 1, 0, n - 1);
	};

	#undef ls
	#undef rs
};

int main() {
    ios::sync_with_stdio(0);
    std::cin.tie(0); std::cout.tie(0);

	int n; cin >> n;
	vector<int> as(n);
	for (auto &x : as) cin >> x;

	vector<vector<int>> poss(n + 1);
	rep(i, 0, n - 1) poss[i].push_back(-1);
	rep(i, 0, n - 1) {
		int x = as[i];
		poss[x].push_back(i);
	}
	
	vector<Info> init(n, 1);
	LazySegTree<Info, Tag> seg(init);
	set<tuple<int, int, int>> S;
	rep(i, 0, n - 1) S.emplace(i, i, i);

	vector<vector<pii>> ops(n + 1);

	rep(x, 0, n - 1) {
		// debug(x, S);
		auto &pos = poss[x];
		reverse(all(pos));
		int last = n;

		for (auto p : pos) {
			auto it = S.lower_bound(make_tuple(p + 1, -1, -1));
			if (it != S.end()) {
				auto l = get<1>(*it);
				// debug(p, l, last);
				if (l < last) {
					auto mn = seg.range_ask(l, last - 1).val;
					ops[x + 1].emplace_back(mn, last - p - 1);
				}
			}			
			last = p;
		}
		last = n;
		for (auto p : pos) {
			int l = n, r = -1;
			while (1) {
				auto it = S.lower_bound(make_tuple(p, -1, -1));
				if (it == S.end()) break;
				else {
					auto [y, l2, r2] = *it;
					if (l2 >= last) break;
					if (r2 < last) {
						S.erase(it);
						chmin(l, l2);
						chmax(r, r2);
					} else {
						S.erase(it);
						S.emplace(y, last, r2);
						seg.range_apply(last, r2, last - y + 1);
						chmin(l, l2);
						chmax(r, last - 1);
					}
				}
			}
			if (l <= r) {
				S.emplace(p, l, r);
				seg.range_apply(l, r, l - p + 1);
			}
			last = p;
		}
	}
	
	set<int> rems;
	rep(i, 1, n) rems.insert(i);
	vector<int> ans(n + 1, n);
	rep(x, 1, n) {
		ops[x].emplace_back(n + 1, n + 1);
		sort(all(ops[x]));
		int last = -1;
		for (auto [l, r] : ops[x]) {
			while (1) {
				auto it = rems.upper_bound(last);
				if (it != rems.end() && *it < l) {
					ans[*it] = x - 1;
					rems.erase(it);
				} else {
					break;
				}
			}
			chmax(last, r);
		}
	}
	rep(i, 1, n) printf("%d%c", ans[i], " \n"[i == n]);
    return 0;
}