#include <stdio.h>

int n, tab[500001], pom, krotnosci[121], pow_120[5001];
int sum_krotnosci=0, licz_pow_120=0, od_gory, od_dolu, do_odjecia, zestawy_odp=0, nadal_dol;
char stop;


int SORT_pow_120(int pocz,int kon) //Przepisane z Cormena
{
int sx,sq,si,sj,pom;
if(pocz<kon)
    {
     sx = pow_120[kon];
     si=pocz-1;
     for(sj=pocz;sj<=kon-1;sj++)
        {
         if (pow_120[sj]<sx) 
            {
             si++;
             pom=pow_120[si]; pow_120[si]=pow_120[sj]; pow_120[sj]=pom;
            }
        }
     pom=pow_120[si+1]; pow_120[si+1]=pow_120[kon]; pow_120[kon]=pom;
     sq=si+1;
     SORT_pow_120(pocz,sq-1);
     SORT_pow_120(sq+1,kon);
    }
return 0;
}




int main()
{
//n = 500000;
scanf("%ld",&n);

//Zerowanie
for (int ii=1; ii<=n; ii++) tab[ii]=0;
for (int ii=1; ii<=5000; ii++) pow_120[ii]=0;
for (int ii=1; ii<=120; ii++) krotnosci[ii]=0;

for (int ii=1; ii<=n; ii++)
	{
	 scanf("%ld",&pom);
	 tab[pom]++; //Ile jest tych wartości
	} 


// PRZYKŁAD 1 - Dla n=500k:
/*tab[130200]=50000; tab[123456]=45000; tab[234566]=9000; tab[183532]=1000; tab[172847]=64000; tab[182773]=31000; //200k
  for (int ii=8001; ii<=10000; ii++) tab[ii]=5;    for (int ii=10001; ii<=50000; ii++) tab[ii]=4; //370k
  for (int ii=250001; ii<=300000; ii++) tab[ii]=2;    for (int ii=400001; ii<=430000; ii++) tab[ii]=1; //500k
// PRZYKŁAD 1 - koniec
{long SUM=0;  for (int ii=1; ii<=n; ii++) SUM+=tab[ii];  if (SUM==n) printf("Suma sie zgadza\n"); else printf("Suma sie NIE zgadza :(\n"); }
*/

// Teraz po kolei, jeśli wystąpień było 120 lub mniej, to zwiększam krotności, a jeśli więcej, to dopisuję tę wartość do pow_120
// Jednocześnie kontroluję liczbę liczb w krotnościach - jeśli mniej niż 20, to dopiszę do pow_120 (od pola 200 w dół są nieużywane elementy).
// Samo pow_120 powinno być posortowane, ale od 201 do odpowiedniego elementu.

for (int ii=1; ii<=n; ii++)
	{
	 if(tab[ii] <= 120)
	 	{
	 	 krotnosci[tab[ii]]++;
	 	 sum_krotnosci++;
	 	}
	 else
	 	{
	 	 licz_pow_120++;
	 	 pow_120[200+licz_pow_120] = tab[ii];
	 	}
	}

//Teraz musiałbym posortować w pow_120
// QUICKSORT!!!
if (licz_pow_120>1)   SORT_pow_120(201,200+licz_pow_120);

// Na razie bez przyspieszeń, tylko krok po kroku, kasuję największy oraz najmniejsze...
// Wskaźniki 'od_dolu' oraz 'od gory' - od 1 do 120 dotyczą krotności, a od 201 (lub trochę mniej, jeśli dopiszę) do 5000 -> listy pow_120

od_dolu=1;
if (licz_pow_120 > 0)   od_gory = 200 + licz_pow_120;
else 
	{
	 od_gory = 120;
	 while (krotnosci[od_gory]==0)   od_gory--;
	}

//for (int ii=1; ii<=10; ii++)   printf("krotnosci[%d]=%d\n",ii,krotnosci[ii]);
//for (int ii=200; ii<=200+licz_pow_120+1; ii++)    printf("pow_120[%d]=%d\n",ii,pow_120[ii]);


// Wystarczy zajmować się tylko tymi od góry :) I trzeba dojść do "n" :)
if (licz_pow_120 > 0)
	{
	 for (od_gory = 200 + licz_pow_120;  od_gory >= 201 ; od_gory--)
	 	{
	 	 n -= pow_120[od_gory]*2-1;
	 	 zestawy_odp++;
	 	 if (n <= 0) 
	 	 	{
	 	 	 printf("%ld",zestawy_odp);
	 	 	 return 0;
	 	 	}
	 	}
	}

//printf("Zostalo jeszcze n=%ld (odp=%ld)\n",n,zestawy_odp);

// Teraz trzeba w krotnościach, od 120 w dół
for (od_gory = 120; od_gory >= 1; od_gory--)
	{
	 if ( (od_gory*2-1)*krotnosci[od_gory] >= n )
	 	{ // To znaczy, że na tej krotności zamkniemy rozważania :)
//	 	 printf("n mod od_gory = %ld\n",n%od_gory);
//	 	 printf("n=%ld   od_gory=%ld\n",n,od_gory);
//	 	 printf("int(n/od_gory)=%ld\n",int(n/od_gory));
	 	 if (n%(od_gory*2-1) == 0)   zestawy_odp += int(n/(od_gory*2-1)) ;
	 	 else   zestawy_odp += int(n/(od_gory*2-1)) + 1;
 	 	 printf("%ld",zestawy_odp);
 	 	 return 0;
	 	}
	 else 
	 	{
	 	 zestawy_odp += krotnosci[od_gory];
	 	 n -= (od_gory*2-1)*krotnosci[od_gory];
//	 	 printf("Dla od_gory=%ld  zostalo  n=%ld  (odp=%ld)\n",od_gory,n,zestawy_odp);
	 	}
	}








/*
nadal_dol=1;
stop=0;
while (!stop)
	{
	 if (od_gory>120)
	 	{
	 	 zestawy_odp++;
	 	 do_odjecia = pow_120[od_gory]-1;
	 	 od_gory--;
	 	 if (pow_120[od_gory]==0) od_gory = 120;
	 	}
	 else if (od_gory<=120)
	 	{
	 	 zestawy_odp++;
	 	 do_odjecia=od_gory-1;
	 	 krotnosci[od_gory]--;
	 	 sum_krotnosci--;
	 	}
	 // I teraz muszę tyle odjąć od dołu, ile jest do_odjęcia
	 
	 for (od_dolu=1; od_dolu <= 120*nadal_dol; od_dolu++)
	 	{
	 	 if (krotnosci[od_dolu]*od_dolu >= do_odjecia) 
	 	 	{ // Jest wystarczająco dużo, żeby odjąć w tej krotności wszystko, co potrzeba.
	 	 	 krotnosci[od_dolu] -= int(do_odjecia/od_dolu);
	 	 	 sum_krotnosci -= int(do_odjecia/od_dolu);
	 	 	 do_odjecia -= int(do_odjecia/od_dolu) * od_dolu;
	 	 	 if (do_odjecia > 0)
	 	 	 	{ // Dokończenie reszty
	 	 	 	 krotnosci[od_dolu] --;
	 	 	 	 sum_krotnosci --;
	 	 	 	 krotnosci[od_dolu-do_odjecia] ++;
	 	 	 	 do_odjecia = 0;
	 	 	 	}
	 	 	 break;
	 	 	}
	 	 else // Czyli w tej krotności jest za mało do odjęcia całości... Więc odejmuję wszystkie.
	 	 	{
	 		 do_odjecia -= krotnosci[od_dolu]*od_dolu;
	 		 sum_krotnosci -= krotnosci[od_dolu];
	 	 	 krotnosci[od_dolu]=0;
	 	 	}
	 	}
	 
	 if (do_odjecia > 0)
	 	{// Muszę przejść z dolnym do pow_120...
	 	 if (od_gory <= 120)
	 	 	{ // To znaczy, że już się skończyło...
	 	 	 printf("%ld",zestawy_odp);
	 	 	 return 0;
	 	 	}
	 	 od_dolu=201;
	 	 nadal_dol = 0;
	 	 while (do_odjecia > 0)
	 	 	{
	 	 	 if (pow_120[od_dolu] >= do_odjecia)
	 	 	}
	 	 
	 	}
	 
	 printf("JESZCZE SPRAWDZIC,  CZY OD_GORY JEST PRAWIDLOWO USTAWIONY\n");
	 
	 
	}
*/



return 0;
}