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# (Mono 4.6.2.0) (judge verdict: Time Limit Exceeded)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;


namespace AtCoder
{
    partial class Program
    {
		static int ReadInt()
        {
            return int.Parse(Console.ReadLine());
        }
        static long ReadLong()
        {
            return long.Parse(Console.ReadLine());
        }
		static int[] ReadIntArray()
        {
            return Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }
        static long[] ReadLongArray()
        {
            return Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
        }
		
        public static int[] ZAlgotithm(string s)
        {
            var len = s.Length;

            var a = new int[len];
            a[0] = len;
            var i = 1;
            var j = 0;
            while (i < len)
            {
                while (i + j < len && s[j] == s[i + j]) j++;
                a[i] = j;

                if (j == 0)
                {
                    i++;
                    continue;
                }

                var k = 1;
                while (i + k < len && k + a[k] < j)
                {
                    a[i + k] = a[k];
                    k++;
                }
                i += k;
                j -= k;
            }

            return a;
        }
        public class MaxHeap<T> : IEnumerable<T>
        {
            private List<T> _list;
            private Comparer<T> _comp;
			
            public int Count
            {
                get
                {
                    return _list.Count;
                }
            }
            public MaxHeap() : this(0) { }
            public MaxHeap(int capacity, Comparison<T> comp=null)
            {
                _list = new List<T>(capacity);

                if (comp == null)
                {
                    _comp = Comparer<T>.Default;
                }
                else
                {
                    _comp = Comparer<T>.Create(comp);
                }
            }
            
            public void Push(T elem)
            {
                Upheap(elem);
            }

            public T Pop()
            {
                return Downheap();
            }

            public T Peek()
            {
                return _list[0];
            }

            
            private void Swap(int i, int j)
            {
                var a = _list[j];
                _list[j] = _list[i];
                _list[i] = a;
            }

            private void Upheap(T elem)
            {
                _list.Add(elem);
                var i = _list.Count - 1;

                while (true)
                {
                    if (i == 0) return;
                    var j = (i - 1) / 2;

                    var e = _list[i];
                    var p = _list[j];

                    var c = _comp.Compare(e, p);
                    if (c > 0)
                    {
                        Swap(i, j);
                        i = j;
                        continue;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            private T Downheap()
            {
                var result = _list[0];

                var last = _list.Count - 1;
                Swap(0, last);
                _list.RemoveAt(last);
                if (_list.Count == 0) return result;

                var i = 0;
                while (true)
                {
                    if (i == _list.Count - 1) return result;
                    var p = _list[i];

                    var j = i * 2 + 1;
                    if (j >= _list.Count) return result;

                    if(j+1 < _list.Count && _comp.Compare(_list[j], _list[j+1]) < 0)
                    {
                        j++;
                    }

                    if (_comp.Compare(_list[i], _list[j]) < 0)
                    {
                        Swap(i, j);
                        i = j;
                    }
                    else
                    {
                        return result;
                    }
                }
            }
            public MaxHeap<T> Copy(Comparison<T> comp=null)
            {
                var c = new MaxHeap<T>(0, comp);
                c._list = _list.ToList();

                return c;
            }
            public MaxHeap(List<T> list)
            {
                _list = list;

                _comp = Comparer<T>.Default;
            }

            public List<T> GetList()
            {
                return _list;
            }

            public IEnumerator<T> GetEnumerator()
            {
                return _list.GetEnumerator();
            }

            IEnumerator IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
        }
        class InputLine
        {
            private string[] _inputs;
            private int _index = 0;

            InputLine(string input)
            {
                _inputs = input.Split();
                _index = 0;
            }

            public static InputLine Read()
            {
                return new InputLine(Console.ReadLine());
            }

            public int NextInt()
            {
                return int.Parse(_inputs[_index++]);
            }
            public long NextLong()
            {
                return long.Parse(_inputs[_index++]);
            }
            public double NextDouble()
            {
                return double.Parse(_inputs[_index++]);
            }
        }
        public static int GCD(int x, int y)
        {
            var a = Math.Max(x, y);
            var b = x + y - a;

            while (b != 0)
            {
                var c = b;
                b = a % b;
                a = c;
            }

            return a;
        }
        public static long GCD(long x, long y)
        {
            var a = Math.Max(x, y);
            var b = x + y - a;

            while (b != 0)
            {
                var c = b;
                b = a % b;
                a = c;
            }

            return a;
        }
        static long ModPower(long x, long y, long mod)
        {
            var bytes = BitConverter.GetBytes(y);
            var bits = new System.Collections.BitArray(bytes);

            var max2 = 0;
            for (int i = bits.Length - 1; i >= 0; i--)
            {
                if (bits[i])
                {
                    max2 = i;
                    break;
                }
            }

            long result = 1;
            for (int i = max2; i >= 0; i--)
            {
                result = (result * result) % mod;
                if (bits[i])
                {
                    result = (result * x) % mod;
                }
            }

            return result;
        }
        
        static long ModFact(long n, long mod)
        {
            long result = 1;

            for (int i = 1; i <= n; i++)
            {
                result = result * i % mod;
            }
            return result;
        }

        static long ModMal(long x, long y, long mod)
        {
            return ((x % mod) * (y % mod)) % mod;
        }

        static long ModDiv(long x, long y, long mod)
        {
            //フェルマーの小定理より、a^(-1) = a^(p-2)
            return ModMal(x, ModPower(y, mod - 2, mod), mod);
        }
        static long ModComb(long n, long r, long mod)
        {
            long numerator = 1;
            for (int i = 0; i < r; i++)
            {
                numerator = ModMal(numerator, n - i, mod);
            }

            long denominator = ModFact(r, mod);

            return ModDiv(numerator, denominator, mod);
        }
        class Graph
        {
            private int _size;
            private List<int>[] _map;

            public IEnumerable<int> this[int i]
            {
                get
                {
                    if (_map[i] == null) return Enumerable.Empty<int>();
                    return _map[i];
                }
            }

            public Graph(int size)
            {
                _size = size;
                _map = new List<int>[size];
            }

            public void Add(int from, int to)
            {
                if (_map[from] == null)
                {
                    _map[from] = new List<int>();
                }
                _map[from].Add(to);
            }
        }
        static long p1097 = 1000000007;
        static void Main(string[] args)
        {
			//↓

            var n = ReadInt();
            var aas = ReadIntArray();

            var LEN = 300001;

            var rests = new int[LEN];
            for (int i = 0; i < n; i++)
            {
                rests[aas[i]]++;
            }

            var heap = new MaxHeap<int>(n);
            for (int i = 0; i < LEN; i++)
            {
                var r = rests[i];
                if (r > 0) heap.Push(r);
            }

            var l = heap.GetList();
            var copy = new List<int>(l.Count);
            
            for (int k = 1; k <= n; k++)
            {
                copy.Clear();
                for (int i = 0; i < l.Count; i++)
                {
                    copy.Add(l[i]);
                }
                var heapc = new MaxHeap<int>(copy);

                var count = 0;
                while (heapc.Count >= k)
                {
                    var r = new List<int>();
                    for (int i = 0; i < k; i++)
                    {
                        var j = heapc.Pop();
                        j--;
                        if (j > 0) r.Add(j);
                    }
                    count++;
                    foreach (var j in r)
                    {
                        heapc.Push(j);
                    }
                }

                Console.WriteLine(count);
            }


			//↑
        }

	}
}