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 Rust (1.15.1) (judge verdict: Accepted)

fn solve(aa: Vec<usize>) -> Vec<usize> {
    let n = aa.len();

    let mut cc = vec![0; n + 1];
    for a in aa {
        cc[a] += 1;
    }

    let mut dd = vec![0; n + 1];
    for c in cc {
        dd[c] += 1;
    }

    let mut d_acc = dd.iter().skip(1).fold(0, |sum, i| sum + i);
    let mut kd_sum = 0;
    let mut ff = vec![0; n + 1];
    for i in (1..(n + 1)) {
        d_acc -= dd[i];
        kd_sum += i * dd[i];
        ff[i] = (kd_sum + i * d_acc) / i;
    }

    let mut ans = vec![0; n + 1];
    for (i, f) in ff.iter().enumerate().rev() {
        for j in (0..(f + 1)).rev() {
            if ans[j] > 0 {
                break;
            }
            ans[j] = i;
        }
    }

    ans[1..].to_vec()
}

#[test]
fn test_solve() {
    assert_eq!(solve(vec![2, 1, 2]), vec![3, 1, 0]);
    assert_eq!(solve(vec![1, 2, 3, 4, 5]), vec![5, 2, 1, 1, 1]);
}

#[allow(unused_macros)]
macro_rules! parse_line {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            iter.next().unwrap().parse::<$t>().unwrap()
        }
    );

    ( $( $t:ty), +) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            ( $(iter.next().unwrap().parse::<$t>().unwrap()),* )
        }
    );
}

#[allow(unused_macros)]
macro_rules! read_line {
    () => {{
        let mut line = String::new();
        ::std::io::stdin().read_line(&mut line).unwrap();
        line.pop();
        line
    }};
}

#[allow(unused_macros)]
macro_rules! parse_vec {
    ( $t:ty ) => {{
        let mut line = String::new();
        ::std::io::stdin().read_line(&mut line).unwrap();
        let iter = line.split_whitespace();
        iter.map(|v| v.parse::<$t>().unwrap()).collect::<Vec<_>>()
    }};
}

fn main() {
    let _n = parse_line!(usize);
    let aa = parse_vec!(usize);
    for ans in solve(aa) {
        println!("{}", ans);
    }
}