Inverting Huffman

Static Huffman coding is an encoding algorithm used mainly for text compression. Given a text made of $N$ different characters, the algorithm chooses $N$ codes, one for each different character, and the text is compressed with those codes. To choose the codes, the algorithm builds a binary rooted tree having $N$ leaves. For $N \ge 2$ the tree is built as follows.

1. For each different character in the text build a tree containing just a single node, and assign to it a weight equal to the number of occurrences of the character within the text.
2. Build a set $s$ containing the above $N$ trees.
3. While $s$ contains more than one tree:
   1. Choose $t_1 \in s$ with minimum weight and remove it from $s$.
   2. Choose $t_2 \in s$ with minimum weight and remove it from $s$.
   3. Build a new tree $t$ with $t_1$ as its left subtree and $t_2$ as its right subtree, and assign to $t$ the sum of the weights of $t_1$ and $t_2$.
   4. Include $t$ into $s$.
4. Return the only tree that remains in $s$.

At steps 3.1 and 3.2 the set $s$ may contain several trees with minimum weight, so the text alone does not fix the shape of the tree. In the text abracadabra the character a occurs 5 times, b and r occur twice each, and c and d occur once each. One run of the algorithm gives code lengths 1, 2, 3, 4, 4 for a, b, r, c, d, and another run gives 1, 3, 3, 3, 3.

For each different character in the text, its code depends on the path that exists, in the final tree, from the root to the leaf corresponding to the character. The length of the code is the number of edges in that path, which is the same as the number of internal nodes in the path.

Given the lengths of the $N$ codes chosen by the algorithm, find the minimum size (total number of characters) that the text can have so that the generated codes have those $N$ lengths.

The first line contains an integer $N$, the number of different characters that appear in the text. ($2 \le N \le 50$)

The second line contains $N$ integers $L_i$, the lengths of the codes the algorithm chose for the different characters. ($1 \le L_i \le 50$, $i = 1, 2, \dots, N$)

At least one tree built as described above produces codes with the given lengths.

Print one line with an integer, the minimum size (total number of characters) that the text can have so that the generated codes have the given lengths.