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 Java8 (OpenJDK 1.8.0) (judge verdict: Time Limit Exceeded)

import java.util.Scanner;

public class Main {
    static Scanner sc;
    public static void main(String[] args) {
        sc = new Scanner(System.in);
        int N = sc.nextInt();
        int[] A = new int[N];
        int[] C = new int[N+1];
        int[] D = new int[N+1];

        for(int i = 0; i < N; i++) {
            A[i] = sc.nextInt();
            C[A[i]] += 1;
        }

        for(int i = 0; i <= N; i++) {
            D[C[i]] += 1;
        }

        int[] Dk_cumsum = new int[N+1];
        int[] D_cumsum = new int[N+1];

        D_cumsum[N] = D[N];
        for(int k = 1; k <= N; k++) {
            Dk_cumsum[k] = Dk_cumsum[k-1] + k*D[k];
            D_cumsum[N-k] = D_cumsum[N-k+1] + D[N-k];
        }

        int[] f = new int[N+1];
        for(int X = 1; X <= N; X++) {
            if(X == N) {
                f[X] = Dk_cumsum[X] / X;
            } else {
                f[X] = (Dk_cumsum[X] + X * D_cumsum[X+1]) / X;
            }
        }

        for(int K = 1; K <= N; K++) {
            //find X maximal, with K <= f(X)
            int x = 0;
            if(f[1] >= K) {
                if(K <= f[N]) {
                    System.out.println(N);
                } else {
                    for (int b = N; b >= 1; b /=2) {
                        while(K <= f[x+b]) x += b;
                    }
                    System.out.println(x);
                }
            } else {
                System.out.println("0");
            }
        }
    }
}