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: Runtime Error)

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
    	Scanner sc = new Scanner(System.in);
    	try {
    		final int N = sc.nextInt();
    		int [] A = new int[N];
    		for (int i=0; i<N; i++) {
    			A[i] = sc.nextInt();
    		}
    		int [] temp = new int[30000];
    		for (int i=0; i<N; i++) {
    			temp[A[i]]++;
    		}

    		ArrayList<Integer> M = new ArrayList<>();
    		for (int i=0; i<temp.length; i++) {
    			if (temp[i] != 0) {
    				M.add(temp[i]);
    			}
    		}

    		Collections.sort(M, Comparator.reverseOrder());

    		for (int Ni=1; Ni<=N; Ni++) {
    			List<Integer> currentList = (ArrayList<Integer>) M.clone();

    			int canChoose = 0;
    			while (true) {
    				int chooseCount = Ni;
    				for (int j=0; j<currentList.size(); j++) {
    					if (currentList.get(j) > 0) {
    						chooseCount--;
        					currentList.set(j, currentList.get(j)-1);
        				}
    					if (chooseCount == 0) {
    						canChoose++;
    						break;
    					}
        			}

    				if (chooseCount != 0) {
    					break;
    				}

    				// Iterator<Integer> it = currentList.iterator();
    				// while (it.hasNext()) {
    				// if (it.next() == 0) {
    				// it.remove();
    				// }
    			    // }
    			}

    			System.out.println(canChoose);
    		}


    	} finally {
    		sc.close();
    	}
    }
}