// Duyệt k từ 1 đến n
// Duyệt i từ 0 đến n-k (mảng con bắt đầu tại i)
// Với mỗi mảng con, dùng mảng đếm tần suất để kiểm tra số nào xuất hiện
// Hoặc tốt hơn: Với mỗi số x, kiểm tra xem có đoạn con độ dài k nào không chứa x không.

// Pseudocode:
for k in 1..n:
  ans = -1
  for x in 1..n:
    bool ok = true
    int last = -1
    // Kiểm tra các khoảng trống
    for each index i of x:
      if i - last > k: ok = false; break
      last = i
    if n - last > k: ok = false
    if ok: ans = x; break
  print ans

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

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        vector<int> a(n);
        for (int i = 0; i < n; i++) cin >> a[i];

        // last[x] lưu vị trí cuối cùng của x
        // max_gap[x] lưu khoảng cách lớn nhất giữa các lần xuất hiện của x
        vector<int> last(n + 1, -1);
        vector<int> max_gap(n + 1, 0);

        for (int i = 0; i < n; i++) {
            int x = a[i];
            if (last[x] != -1) {
                max_gap[x] = max(max_gap[x], i - last[x]);
            } else {
                // Lần đầu xuất hiện, khoảng cách từ đầu mảng (vị trí -1)
                max_gap[x] = max(max_gap[x], i - (-1)); 
            }
            last[x] = i;
        }

        // Kiểm tra khoảng cách từ lần xuất hiện cuối cùng đến cuối mảng
        for (int x = 1; x <= n; x++) {
            if (last[x] != -1) {
                max_gap[x] = max(max_gap[x], n - last[x]);
            }
        }

        // Tính kết quả
        // ans[k] = số nhỏ nhất có max_gap < k
        vector<int> ans(n + 1, -1);

        // Cách 1: Duyệt k và tìm min
        // O(n^2)
        for (int k = 1; k <= n; k++) {
            int min_val = INT_MAX;
            for (int x = 1; x <= n; x++) {
                if (max_gap[x] < k) { // Nếu khoảng cách nhỏ hơn k, x có trong mọi đoạn
                    min_val = min(min_val, x);
                }
            }
            if (min_val == INT_MAX) cout << -1 << " ";
            else cout << min_val << " ";
        }
        cout << "\n";
    }
}

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

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        vector<int> a(n);
        for (int i = 0; i < n; i++) cin >> a[i];

        vector<int> last(n + 1, -1);
        vector<int> best(n + 1, 0);

        // Tính khoảng cách giữa các lần xuất hiện của mỗi x
        for (int i = 0; i < n; i++) {
            int x = a[i];
            best[x] = max(best[x], i - last[x] - 1); // -1 vì khoảng cách là số phần tử nằm giữa
            last[x] = i;
        }
        for (int x = 1; x <= n; x++) {
            best[x] = max(best[x], n - last[x] - 1);
        }

        vector<int> ans(n + 1, -1);

        // Gán cho mọi k >= best[x] + 1
        for (int x = 1; x <= n; x++) {
            if (last[x] == -1) continue; // số không xuất hiện
            int need = best[x] + 1; // k cần thiết để x xuất hiện
            if (need <= n) {
                // Nếu ans[need] chưa có, gán. Nếu đã có, ta chỉ cần gán khi x nhỏ hơn (nhưng ta duyệt x tăng dần nên không cần)
                // Tuy nhiên, ta phải fill all k >= need
                // Tối ưu: Nếu ans[need] đã có giá trị, nó là x nhỏ hơn (vì duyệt từ 1). Nhưng ta cần fill k >= need
                // Nếu ans[need] != -1, nó đã được gán bởi số nhỏ hơn. Ta không cần gán lại.
                // Nhưng ta phải fill các k > need nếu chưa có.
                if (ans[need] == -1) ans[need] = x;
            }
        }

        // Propagate: Nếu k có đáp án là -1, nó có thể lấy đáp án từ k-1 (vì k càng lớn, điều kiện càng dễ thỏa)
        // Tuy nhiên, theo đề bài, ta cần số NHỎ NHẤT. 
        // Nếu ans[k] = -1, ta không thể lấy ans[k-1] vì ans[k-1] có thể lớn hơn.
        // Phải làm gì?
        // Ta chỉ fill ans[need] = x. Sau đó ta cần tìm min cho mọi k.
        // Ví dụ: x=3 cần k=3. ans[3]=3. x=5 cần k=2. ans[2]=5.
        // Kết quả k=3: min(ans[3], ans[...]) -> 3.
        // Kết quả k=4: min(ans[4], ans[3], ans[2]) ...

        // Cách khác: Dùng vector res[k] lưu giá trị nhỏ nhất cho độ dài k.
        vector<int> res(n + 2, INT_MAX);
        for (int x = 1; x <= n; x++) {
            if (last[x] == -1) continue;
            int need = best[x] + 1;
            if (res[need] > x) res[need] = x;
        }

        int current_min = INT_MAX;
        for (int k = 1; k <= n; k++) {
            if (res[k] < current_min) current_min = res[k];
            if (current_min == INT_MAX) cout << -1 << " ";
            else cout << current_min << " ";
        }
        cout << "\n";
    }
}