Problem:
Score : 600 points

Problem Statement

Takahashi has N cards. The i-th of these cards has an integer A_i written on it.

Takahashi will choose an integer K, and then repeat the following operation some number of times:

Choose exactly K cards such that the integers written on them are all different, and eat those cards. (The eaten cards disappear.)

For each K = 1,2, \ldots, N, find the maximum number of times Takahashi can do the operation.

Constraints

1 \le N \le 3 \times 10^5

1 \le A_i \le N

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 \ldots A_N

Output

Print N integers.
The t-th (1 \le t \le N) of them should be the answer for the case K=t.

Sample Input 1

3
2 1 2

Sample Output 1

3
1
0

For K = 1, we can do the operation as follows:

Choose the first card to eat.

Choose the second card to eat.

Choose the third card to eat.

For K = 2, we can do the operation as follows:

Choose the first and second cards to eat.

For K = 3, we cannot do the operation at all. Note that we cannot choose the first and third cards at the same time.

Sample Input 2

5
1 2 3 4 5

Sample Output 2

5
2
1
1
1

Sample Input 3

4
1 3 3 3

Sample Output 3

4
1
0
0

Solution in PyPy3 (2.4.0) (judge verdict: Runtime Error)

import sys
input = sys.stdin.readline
 
#input
N = int(input())
A = list(map(int, input().split()))

#output
from collections import Counter
import numpy as np

l = Counter(A).most_common()
l = [b for a, b in l]
M = len(l)
O = l[0]

number_of_operation = [0] * O
maximum_operation = [0] * N
operation_matrix = np.zeros((O, M), int)

for m in range(M):
    operation_matrix[0:l[m], m] += 1

for o in range(O):
    number_of_operation[o] = sum(operation_matrix[o])

for K in range(N):
    temp_number_of_operation = list(number_of_operation)
    for o in range(O-1):
        p, q = divmod(temp_number_of_operation[o], K+1)
        if p > 0:
            temp_number_of_operation[o+1] += q
        maximum_operation[K] += p
    maximum_operation[K] += number_of_operation[O-1]//(K+1)

for m in maximum_operation:
    print(m)