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 C (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>

#undef DEBUG

#ifdef DEBUG
struct testdata{
    int N;
    int A[3*100000];
    int a[3*100000];
} td[] = {
    {16, {3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2, 2, 2}, {16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
    {7, {1,1,1,1, 1, 2, 2},{7,2,0,0,0,0,0}},
    {3, {2, 1, 2}, {3, 1, 0}},
    {5, {1, 2, 3, 4, 5}, {5, 2, 1, 1, 1}},
    {4, {1, 3, 3, 3}, {4, 1, 0, 0}},
};
#endif

int
cmp(const void *a, const void *b)
{
    return *(int *)b - *(int *)a;
}

void
solver(int n, int *a, int *aaa)
{
    int i, j, r;
    int A[3*100000];
    int v = 0;
    int ans;

    bzero(A, sizeof(A));

    for (i=0; i<n; i++) {
        if (A[a[i]-1]==0)
            v++;
        A[a[i]-1]++;
    }
    qsort(A, n, sizeof(int), cmp);
    printf("%d\n", n);
    ans = n;
    j = 0;
    r = n;
    for (i=2; i<n+1; i++){
        printf("i: %d, j: %d, r: %d\n", i, j, r);
        if (r<(i-j)) {
            if (aaa!=NULL) {
                printf("0 (%d)\n", aaa[i-1]);
            }
            else {
                printf("0\n");
            }
            continue;
        }
        for (; j<n; j++) {
            printf("       j: %d, r: %d v: %d\n", j, r, v);
            if (v==i-j) {
                ans = A[j+v-1]<n/i?A[j+v-1]:n/i;
                break;
            }
            if (v<i-j) {
                ans = 0;
                break;
            }
            if (n/i<A[j]) {
                v--;
                r -= A[j];
            }
            else {
                ans = r/(i-j);
                break;
            }
        }        
        if (aaa!=NULL) {
            printf("%d (%d)\n", ans, aaa[i-1]);
        }
        else {
            printf("%d\n", ans);
        }
    }
}

int
main(int argc, char *argv[])
{
    int i;
    int j;
    int N;
    int A[3*100000];

#ifdef DEBUG
    for (i=0; i<5; i++) {
        printf("Test case %d\n", i+1);
        solver(td[i].N, td[i].A, td[i].a);
    }
#else
    scanf("%d", &N);
    for (i=0; i<N; i++)
        scanf("%d", A+i);
    solver(N, A, NULL);
#endif

    return 0;
}