Problem:
Huffman Coding

We want to encode a given string $S$ to a binary string. Each alphabet character in $S$ should be mapped to a different variable-length code and the code must not be a prefix of others.

Huffman coding is known as one of ways to obtain a code table for such encoding.

For example, we consider that appearance frequencycies of each alphabet character in $S$ are as follows:

a

b

c

d

e

f

freq.

45

13

12

16

9

5

code

0

101

100

111

1101

1100

We can obtain "Huffman codes" (the third row of the table) using Huffman's algorithm.

The algorithm finds a full binary tree called "Huffman tree" as shown in the following figure.

To obtain a Huffman tree, for each alphabet character, we first prepare a node which has no parents and a frequency (weight) of the alphabet character. Then, we repeat the following steps:

Choose two nodes, $x$ and $y$, which has no parents and the smallest weights.

Create a new node $z$ whose weight is the sum of $x$'s and $y$'s.

Add edge linking $z$ to $x$ with label $0$ and to $y$ with label $1$. Then $z$ become their parent.

If there is only one node without a parent, which is the root, finish the algorithm. Otherwise, go to step 1.

Finally, we can find a "Huffman code" in a path from the root to leaves.

Task

Given a string $S$, output the length of a binary string obtained by using Huffman coding for $S$.

Input

$S$

A string $S$ is given in a line.

Output

Print the length of a binary string in a line.

Constraints

$1 \le |S| \le 10^5$

$S$ consists of lowercase English letters.

Sample Input 1

abca

Sample Output 1

6

Sample Input 2

aaabbcccdeeeffg

Sample Output 2

41

Sample Input 3

z

Sample Output 3

1

Solution in C# (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;



namespace CSharpSample01
{

    class HNode
    {
        public char ch;
        public int num;
        public bool is_leaf;
        public HNode par;
        public HNode left;
        public HNode right;
        public HNode(char c, int n, bool leaf)
        {
            ch = c;
            num = n;
            is_leaf = leaf;
            par = null;
            left = null;
            right = null;
        }
    }

    class Huffman
    {
        private List<HNode> sorted_node_list;
        readonly string S;
        Dictionary<char, string> code_dic;
        HNode root;

        public Huffman(string s)
        {
            S = s;           
            Initiate_sorted_node_list();
            CreateHuffman();
            Coding();
        }

        //node_listの初期化
        private void Initiate_sorted_node_list()
        {
            Dictionary<char, int> freq = new Dictionary<char, int>();
            sorted_node_list = new List<HNode>();

            foreach (var c in S)
            {
                if (freq.ContainsKey(c)) freq[c]++;
                else freq[c] = 1;
            }
            foreach(var s in freq.OrderBy(x => x.Value))
            {
                sorted_node_list.Add(new HNode(s.Key, s.Value, true));
            }
        }

        //node_listからハフマン木を作る
        private void CreateHuffman()
        {
            //foreach (var s in sorted_node_list) Console.Write($"{s.ch}:{s.num} ");
            //Console.WriteLine();
            HNode first = sorted_node_list.First();
            HNode n = new HNode('?', first.num, false);
            n.left = first;
            sorted_node_list.Remove(sorted_node_list.First());

            if(sorted_node_list.Count >= 1)
            {
                HNode r = sorted_node_list.First();
                n.right = r;
                n.num += r.num;
                sorted_node_list.Remove(sorted_node_list.First());
            }

            sorted_node_list.Add(n);
       
            while (sorted_node_list.Count >= 2)
            {
                sorted_node_list = sorted_node_list.OrderBy(x => x.num).ToList();

                //foreach (var s in sorted_node_list) Console.Write($"{s.ch}:{s.num} ");
                //Console.WriteLine();

                HNode left = sorted_node_list.First();
                sorted_node_list.Remove(sorted_node_list.First());
                HNode right = sorted_node_list.First();
                sorted_node_list.Remove(sorted_node_list.First());

                HNode joint = new HNode('?', left.num + right.num, false);
                joint.left = left;
                joint.right = right;

                sorted_node_list.Add(joint);
            }

            root = sorted_node_list.First();
            sorted_node_list.Remove(sorted_node_list.First());
        }

        //完成したハフマン木から文字列S内の文字を符号化
        //左を0右を1とする
        private void Coding()
        {
            code_dic = new Dictionary<char, string>();
            Preorder(root, "");
        }

        //行きがけ順で符号化
        private void Preorder(HNode cur, string code)
        {
            if (cur == null) return;

            if(cur.right == null && cur.left == null)
            {
                //Console.WriteLine($"{cur.ch}:{code}");
                code_dic[cur.ch] = code;
                return;
            }

            Preorder(cur.left, code + "0");
            Preorder(cur.right, code + "1");
        }
        
        //引数chの符号を返す
        public string GetCode(char ch)
        {
            if (!code_dic.ContainsKey(ch)) return "";
            return code_dic[ch];
        }

    }

    
    class Program
    {
        
        static void Main(string[] args)
        {
            string S = Console.ReadLine();

            Huffman h = new Huffman(S);
            
            long cnt = 0;
            foreach(var c in S)
            {
                //Console.WriteLine($"{c}:{h.GetCode(c)}");
                cnt += (long)h.GetCode(c).Length;
            }

            Console.WriteLine(cnt);
            
        }
    }

}