Problem:
Score : 300 points

Problem Statement

You are given a string s.
Among the different substrings of s, print the K-th lexicographically smallest one.

A substring of s is a string obtained by taking out a non-empty contiguous part in s.
For example, if s = ababc, a, bab and ababc are substrings of s, while ac, z and an empty string are not.
Also, we say that substrings are different when they are different as strings.

Let X = x_{1}x_{2}...x_{n} and Y = y_{1}y_{2}...y_{m} be two distinct strings. X is lexicographically larger than Y if and only if Y is a prefix of X or x_{j} > y_{j} where j is the smallest integer such that x_{j} \neq y_{j}.

Constraints

1 ≤ |s| ≤ 5000

s consists of lowercase English letters.

1 ≤ K ≤ 5

s has at least K different substrings.

Partial Score

200 points will be awarded as a partial score for passing the test set satisfying |s| ≤ 50.

Input

Input is given from Standard Input in the following format:

s
K

Output

Print the K-th lexicographically smallest substring of K.

Sample Input 1

aba
4

Sample Output 1

b

s has five substrings: a, b, ab, ba and aba.
Among them, we should print the fourth smallest one, b.
Note that we do not count a twice.

Sample Input 2

atcoderandatcodeer
5

Sample Output 2

andat

Sample Input 3

z
1

Sample Output 3

z

Solution in C# (Mono 4.6.2.0) (judge verdict: Time Limit Exceeded)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Net.Mail;

namespace Contest
{
    class Scanner
    {
        private string[] line = new string[0];
        private int index = 0;
        public string Next()
        {
            if (line.Length <= index)
            {
                line = Console.ReadLine().Split(' ');
                index = 0;
            }
            var res = line[index];
            index++;
            return res;
        }
        public int NextInt()
        {
            return int.Parse(Next());
        }
        public long NextLong()
        {
            return long.Parse(Next());
        }
        public string[] Array()
        {
            line = Console.ReadLine().Split(' ');
            index = line.Length;
            return line;
        }
        public int[] IntArray()
        {
            var array = Array();
            var result = new int[array.Length];
            for (int i = 0; i < array.Length; i++)
            {
                result[i] = int.Parse(array[i]);
            }

            return result;
        }
        public long[] LongArray()
        {
            var array = Array();
            var result = new long[array.Length];
            for (int i = 0; i < array.Length; i++)
            {
                result[i] = long.Parse(array[i]);
            }

            return result;
        }
    }

    class Program
    {
        private string S;
        private int K;
        private void Scan()
        {
            var sc = new Scanner();
            S = sc.Next();
            K = sc.NextInt();
        }

        public void Solve()
        {
            Scan();
            int N = S.Length;
            var d = new Dictionary<char, List<int>>();
            for (char c = 'a'; c <= 'z'; c++)
            {
                d[c] = new List<int>();
            }

            for (int i = 0; i < N; i++)
            {
                d[S[i]].Add(i);
            }

            for (char c = 'a'; c <= 'z'; c++)
            {
                var hs = new HashSet<string>();
                foreach (int i in d[c])
                {

                    for (int j = N - 1; j >= i; j--)
                    {
                        string s = S.Substring(i, j - i + 1);
                        if (!hs.Add(s))
                        {
                            break;
                        }
                    }
                }

                if (hs.Count < K)
                {
                    K -= hs.Count;
                }
                else
                {
                    var ar = hs.ToArray();
                    Array.Sort(ar);
                    Console.WriteLine(ar[K - 1]);
                    return;
                }
            }
        }

        static void Main(string[] args)
        {
            new Program().Solve();
        }
    }
}