Codeforces Problem 388A. Fox and Box Accumulation

A. Fox and Box Accumulation

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Fox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box).

Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.

Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?

Input

The first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).

Output

Output a single integer — the minimal possible number of piles.

Sample test(s)

input

3
0 0 10

output

2

input

5
0 1 2 3 4

output

1

input

4
0 0 0 0

output

4

input

9
0 1 0 2 0 1 1 2 10

output

3

Note

In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.

In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).

题意：有N个盒子，承重（xi)不一样，但每个盒子重为1.求最少要分多少堆。 思路：刚开始从大到小取盒子，越想越复杂。当出现多个重量相同的盒子时候，该怎么取呢？是将最大的放下，然后每放一个盒子，最底下的盒子减一?那要承重全部一样呢？比如  2,2,2,2,2,2,2,2,2,2,2  这时候应该是4堆，如果按上面的策略，会分成6堆，这也是我第10条数据没过得原因。要是按从大到小一个一个取盒子，并统计个数的话，将有可能不是最优的。或者会出错。比如，10 5 2 1 1 1 1 1 1，以上策略只需要一堆，实际上应该是4堆。那要是当前剩下的承重和当前要放的盒子的承重中取小的呢？这也许可以，我还没试着写。 但是换一个思路来想这个问题呢？我从小到大取的话，那么每次取的盒子都是目前最优的盒子，而当前已选定的盒子个数用一个数据Strength记录下来，并对已选过的盒子赋一个较大不可能的值，这样每次排序以后，已选的盒子就会排在后面，在判定的时候提前进行判定，就能满足我们的要求。 以下是我写的，代码很粗糙：

#include <stdio.h>
#define MAXN 200
void shellsort(int v[], int n);

int main(){
    int n, i, piles;
    int x[MAXN];
    piles = 0;
    scanf("%d", &n);
    for(i = 0; i < n; ++i){
        scanf("%d", x+i);
    }
   
    int flag = 1;
    while(flag){
        shellsort(x, n);    //from small to large
        flag = 0;
        int strength = 0;
        for(i = 0; i < n; ++i){
            if(x[i] != 101 && strength <= x[i]){
                flag = 1;
                x[i] = 101;
                strength++;
            }
        }
        if(flag)
            ++piles;
    }

    printf("%d", piles);

    return 0;   

}

/* shell sorting */
void shellsort(int v[], int n){
    int gap, i, j, temp;
    for(gap = n/2; gap > 0; gap /= 2)
        for(i = gap; i < n; ++i)
            for(j = i-gap; j >= 0 && v[j] > v[j+gap]; j -= gap){
                temp = v[j];
                v[j] = v[j+gap];
                v[j+gap] = temp;
            }
}