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




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

#define MAXN	300001
int CardCounter[MAXN];
struct sCard
{
	int kind;
	int ONum; // Original Number
};
sCard Card[MAXN];




int compare(const void *a, const void *b)   
{
	sCard *num1 = (sCard *)a;    
	sCard *num2 = (sCard *)b;    

	if (num1->ONum < num2->ONum)
		return -1;    

	if (num1->ONum > num2->ONum)
		return 1;   

	return 0;    
}


void Sort(int N, sCard *Card)
{
/*	for (int i = 0; i < N; i++)
		for (int j = i; j < N; j++)
			if (Card[i].ONum < Card[j].ONum)
				Swap(&Card[i], &Card[j]);
	*/			
	qsort(Card, N, sizeof(sCard), compare);
}




int main()
{
#ifdef _WIN32
	freopen("input.txt", "r", stdin);
#endif

	int N;
	scanf("%d", &N);

	for (int n = 0; n < N; n++)
	{
		int t = 0;
		scanf("%d", &t);
		CardCounter[t]++;
	}


	int CardIndex = 0;
	int _CardIndex = 0;
	for (int n = 0; n < MAXN; n++)
	{
		if (CardCounter[n])
		{
			Card[CardIndex].kind = n;
			Card[CardIndex].ONum = CardCounter[n];
			CardIndex++;
		}
	}

	_CardIndex = CardIndex;
	Sort(CardIndex, Card);
#ifdef _WIN32
	printf("CardIndex : %d\n", _CardIndex);
	for (int i = 0; i < CardIndex; i++)
		printf("Card %d : %d\n", Card[i].kind, Card[i].ONum);
#endif


	printf("%d\n", N); // case 1
	for (int K = 2; K <= N; K++)
	{
		// ReInit
		int OperationCnt = 0;
		int OldNum = 0;
		for(int Pnt = 0; Pnt < CardIndex;)
		{
			if (Pnt + K > CardIndex)
				break;

			OperationCnt += ((CardIndex - Pnt) / K) * (Card[Pnt].ONum - OldNum);
			
			while (Pnt + 1 < CardIndex)
				if (Card[Pnt].ONum != Card[Pnt+1].ONum)
				{
					Pnt++;
					OldNum = Card[Pnt].ONum;
					break;
				}
				else
					Pnt++;
		}

		printf("%d\n", OperationCnt);
	}



	return 0;
}