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



Sample input:
3
2 1 2


Sample output:
3
1
0

Submission status: Time Limit Exceeded

Solution code:
import subprocess
import gzip, base64, os
import stat

gz = b'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'
bin = gzip.decompress(base64.b64decode(gz))
p = os.path.dirname(__file__)
pymain = os.path.join(p, "a.out")
with open(pymain, "wb") as f:
    f.write(bin)
os.chmod(pymain, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
if p == "":
    pymain = "./" + pymain
subprocess.call(pymain)


# compiled by pythran
'''
#pythran export main2()
import numpy as np
i8 = np.int64
i4 = np.int32

def push(val, que, sz):
    i = sz
    while i > 0:
        parent = (i - 1) // 2
        if que[parent] < val:
            que[i] = que[parent]
            i = parent
        else:
            que[i] = val
            break
    else:
        que[0] = val

def pop(que, sz):
    if sz == 0:
        return 0
    ret = que[0]
    sz -= 1
    val = que[sz]
    i = 0
    while True:
        child = 2 * i + 1
        if child >= sz:
            que[i] = val
            break
        if que[child] > que[child + 1]:
            if que[child] > val:
                que[i] = que[child]
                i = child
            else:
                que[i] = val
                break
        else:
            if que[child + 1] > val:
                que[i] = que[child + 1]
                i = child + 1
            else:
                que[i] = val
                break
    return ret


def solve(A, N):
    count = np.zeros(N + 1, i8)
    for c in A:
        count[c] += 1
    que0 = np.empty(N, i8)
    sz = 0
    for i in range(N + 1):
        if count[i] > 0:
            push(count[i], que0, sz)
            sz += 1
    num = sz
    ans = np.zeros(N, i8)
    ans[0] = A.shape[0]
    work = np.empty(N, i8)
    for m in range(2, N + 1):
        que = que0[:num].copy()
        sz = num
        x = 0
        while True:
            for i in range(m):
                if sz == 0:
                    work[m - 1] = 0
                    break
                work[i] = pop(que, sz)
                sz -= 1
            if work[m - 1] == 0:
                break
            x += 1
            for i in range(m):
                if work[i] > 1:
                    push(work[i] - 1, que, sz)
                    sz += 1
                else:
                    break
        ans[m - 1] = x
    return ans


def main2():
    stdin = open('/dev/stdin')
    N = int(stdin.readline())
    A = np.empty(N, i8)
    for i, c in enumerate(map(int, stdin.readline().split())):
        A[i] = c
    ans = solve(A, N)
    s = '\n'.join(map(str, ans.tolist()))
    print(s)

'''

Submission status: Time Limit Exceeded

Solution code:
import sys
input = sys.stdin.readline

N=int(input())
A=list(map(int,input().split()))

from collections import Counter

C=Counter(A)

LIST=sorted(C.values())
LEN=len(LIST)
SUM=sum(LIST)
BASE=[]
BASESUM=0

MAX=LIST[-1]

for k in range(1,N+1):
    if k>LEN:
        sys.stdout.write("0"+"\n")
    else:
        BASE.append(LIST[-k])
        #print(BASE)

        BASESUM+=LIST[-k]

        REST=SUM-BASESUM
        REST0=REST

        MIN=LIST[-k]
        #MAX=LIST[-1]

        if LIST[-1]*k-BASESUM<=REST:
            sys.stdout.write(str(SUM//k)+"\n")
            continue

        while MIN!=MAX:
            mid=(MIN+MAX+1)//2
            REST=REST0

            for b in BASE[::-1]:
                if b<mid:
                    REST-=mid-b
                if REST<0 or b>=mid:
                    break

            #print(MAX,MIN,mid,REST)

            if REST>=0:
                MIN=mid
            else:
                MAX=mid-1

        sys.stdout.write(str(MIN)+"\n")

Submission status: Time Limit Exceeded

Solution code:
import sys
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
A_ = [0] * (N+1)
for a in A:
    A_[a] += 1
A_ = sorted(A_)
c = 0
for i in range(N+1):
    A_[i] = c = A_[i] + c
A_.reverse()

Ans = [N//i for i in range(1, N+2)]
for j, a in enumerate(A_[1:], 1):
    for i in range(N):
        d = a//(i+1)
        if Ans[i+j] > d:
            Ans[i+j] = d
        if d==0:
            break
del Ans[-1]
print("\n".join(map(str, Ans)))

Submission status: Time Limit Exceeded

Solution code:
import sys
input = sys.stdin.readline
import collections
 
n = int(input())
a_list = list(map(int, input().split()))

c_list = list(collections.Counter(a_list).values())
c_list.sort(reverse=True)
c_list_true = c_list

for i in range(n):
  c_list = c_list_true
  cnt = 0
  if len(c_list) < i+1:
    print(cnt)
  else:
    while True:
      c_list_1 = list(map(lambda x:x-1 , c_list[:i+1]))
      c_list = c_list_1 + c_list[i+1:]
      c_list.sort(reverse=True)
      if -1 in c_list:
        break
      cnt += 1
    
    print(cnt)

Submission status: Time Limit Exceeded

Solution code:
from collections import Counter
N = int(input())
A = list(map(int, input().split()))
C = Counter(A)
C = list(C.values())
C.sort()
n = len(C)
m = max(C)
S = [0]*(m+1)
b = 0
for i in range(n):
    c = C[i]
    if b<c:
        for j in range(b+1, c+1):
            S[j] = S[j-1]+(n-i)
        b = c
for i in range(1, N+1):
    ok = 0
    ng = N+1
    while ng-ok>1:
        mid = (ok+ng)//2
        if S[min(m, mid)]>=mid*i:#midが条件を満たすか
            ok = mid
        else:
            ng = mid
    print(ok)

Submission status: Time Limit Exceeded

Solution code:
n = int(input())
a_list = list(map(int, input().split()))
a_set = set(a_list)
i = 0
duplicates = []
for ai in a_set:
    duplicates.append(len([a for a in a_list if a == ai]))
duplicates.sort(reverse=True)
for k in range(1, len(a_set)):
    times = 0
    dup = duplicates[:]
    while True:
        if(dup[k-1] < dup[k]):
            dup_former = [ d for d in dup if d >= dup[k-1] ]
            dup_former.sort(reverse=True)
            dup = dup_former + [ d for d in dup if d < dup[k-1]]
        if(dup[k-1] == 0):
            break
        for i in range(k):
            dup[i] -= 1
        times += 1
    print(times)
print(duplicates[-1])
for i in range(n - len(a_set)):
    print("0")

Submission status: Time Limit Exceeded

Solution code:
import sys
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
A_ = [0] * (N+1)
for a in A:
    A_[a] += 1
A_ = sorted(A_)
c = 0
for i in range(N+1):
    A_[i] = c = A_[i] + c
A_.reverse()

Ans = A_[:]

for i in range(1, N):
    for j, a in enumerate(A_):
        d = a//(i+1)
        if Ans[i+j] > d:
            Ans[i+j] = d
        if d==0:
            break
    if j==0:
        for ii in range(i+1, N):
            Ans[ii] = 0
        break
del Ans[-1]
print("\n".join(map(str, Ans)))

Submission status: Time Limit Exceeded

Solution code:
import sys
input = sys.stdin.readline

N=int(input())
A=list(map(int,input().split()))

from collections import Counter

C=Counter(A)

LIST=sorted(C.values())
LEN=len(LIST)
SUM=sum(LIST)
BASE=[]
BASESUM=0

MAX=LIST[-1]

for k in range(1,N+1):
    if k>LEN:
        print(0)
    else:
        BASE.append(LIST[-k])
        #print(BASE)

        BASESUM+=LIST[-k]

        REST=SUM-BASESUM
        REST0=REST

        MIN=LIST[-k]
        #MAX=LIST[-1]

        if LIST[-1]*k-BASESUM<=REST:
            print(SUM//k)
            continue

        while MIN!=MAX:
            mid=(MIN+MAX+1)//2
            REST=REST0

            for b in BASE[::-1]:
                if b<mid:
                    REST-=mid-b
                if REST<0 or b>=mid:
                    break

            #print(MAX,MIN,mid,REST)

            if REST>=0:
                MIN=mid
            else:
                MAX=mid-1

        print(MIN)

Submission status: Time Limit Exceeded

Solution code:
import numpy as np
def f(x):
    return int(x) - 1
N = int(input())
A = map(f, input().split())
C = [0]*N
for a in A:
    C[a] += 1

C = sorted(C, reverse=True)

def g(cnp, i):
    res = 0
    while cnp[i] > 0:
        res += cnp[i]
        cnp[0:i + 1] -= cnp[i]
        cnp = np.sort(cnp)[::-1]
    return res
    
for i in range(N):
    cnp = np.array(C)
    print(g(cnp, i))

Submission status: Time Limit Exceeded

Solution code:
from collections import Counter
from copy import deepcopy

n = int(input())
a = list(map(int, input().split()))
c = Counter(a)

for k in range(1, n + 1):
    cx = deepcopy(c)

    count = 0

    while k <= len(cx):
        # print(cx)
        mc = cx.most_common()
        for key, _ in mc[:k]:
            cx[key] -= 1
            if cx[key] < 1:
                del cx[key]
        count += 1

    print(count)

Submission status: Time Limit Exceeded

Solution code:
def Sort(risuto):
    kotae=risuto[:]
    kotae.sort()
    for i in range(n//2):
       henkou=n-i-1
       kotae[henkou]+=kotae[i]
       kotae[i]=kotae[henkou]-kotae[i]
       kotae[henkou]-=kotae[i]
    return kotae

def check(risuto,n):
    for i in range(n):
        risuto[i]-=1
        #if(risuto[i]==0):
        #    return 0
        if(risuto[i]==-1):
            return -1
    return 1


n=int(input())
a=list(map(int,input().split()))

#print(n,a)

count=[0]*n
for i in range(n):
    count[a[i]-1]+=1

#print(Sort(count))
#count.sort()
#for i in range(n//2):
#    henkou=n-i-1
#    count[henkou]+=count[i]
#    count[i]=count[henkou]-count[i]
#    count[henkou]-=count[i]
count=Sort(count)
#print(count)

for i in range(1,n+1):
    #print(str(i)+"番目")
    nokori=n
    kaisu=0
    temp=count[:]

    for j in range(n):
        kaisu+=1
        #print(temp)
        if(check(temp,i)==-1):
            #print(temp)
            kaisu-=1
            break
        
        #temp[0]-=1
        #temp[1]-=1
        temp=Sort(temp)
        nokori-=i
        if(nokori-i<0):
            break

    print(kaisu)