Problem:
Score : 600 points

Problem Statement

A subsequence of a string S is a string that can be obtained by deleting zero or more characters from S without changing the order of the remaining characters.
For example, arc, artistic and (an empty string) are all subsequences of artistic; abc and ci are not.

You are given a string A consisting of lowercase English letters.
Find the shortest string among the strings consisting of lowercase English letters that are not subsequences of A.
If there are more than one such string, find the lexicographically smallest one among them.

Constraints

1 \leq |A| \leq 2 \times 10^5

A consists of lowercase English letters.

Input

Input is given from Standard Input in the following format:

A

Output

Print the lexicographically smallest string among the shortest strings consisting of lowercase English letters that are not subsequences of A.

Sample Input 1

atcoderregularcontest

Sample Output 1

b

The string atcoderregularcontest contains a as a subsequence, but not b.

Sample Input 2

abcdefghijklmnopqrstuvwxyz

Sample Output 2

aa

Sample Input 3

frqnvhydscshfcgdemurlfrutcpzhopfotpifgepnqjxupnskapziurswqazdwnwbgdhyktfyhqqxpoidfhjdakoxraiedxskywuepzfniuyskxiyjpjlxuqnfgmnjcvtlpnclfkpervxmdbvrbrdn

Sample Output 3

aca

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;

public class Program
{
    private char[] A;
    private int N;

    public void Solve()
    {
        var sc = new Scanner();
        A = sc.Next().ToCharArray();
        N = A.Length;

        var nextIndex = new int[N + 2, 26];
        var tmpIndex = new int[256];
        for (char c = 'a'; c <= 'z'; c++)
        {
            tmpIndex[c] = N + 1;
        }

        for (int i = N - 1; i >= 0; i--)
        {
            for (char c = 'a'; c <= 'z'; c++)
            {
                nextIndex[i + 1, c - 'a'] = tmpIndex[c];
            }

            tmpIndex[A[i]] = i + 1;
        }

        for (char c = 'a'; c <= 'z'; c++)
        {
            nextIndex[0, c - 'a'] = tmpIndex[c];
        }

        int[] cost = new int[N + 2];
        for (int i = 0; i <= N + 1; i++)
        {
            cost[i] = int.MaxValue;
        }

        cost[N + 1] = 0;
        int t = 1;

        bool[] f = new bool[256];


        for (int i = N - 1; i >= 0; i--)
        {
            f[A[i]] = true;
            bool b = true;
            for (char c = 'a'; c <= 'z'; c++)
            {
                b &= f[c];
            }
            cost[i + 1] = t;
            if (b)
            {
                t++;
                f = new bool[256];
            }
        }

        cost[0] = t;
        int len = cost[0];
        int index = 0;
        char[] ans = new char[len];
        //Console.WriteLine();
        for (int i = 0; i < len; i++)
        {
            for (char c = 'a'; c <= 'z'; c++)
            {
                if (cost[index] - 1 == cost[nextIndex[index, c - 'a']])
                {
                    ans[i] = c;
                    index = nextIndex[index, c - 'a'];
                    break;
                }
            }

            // Console.WriteLine();
        }

        Console.WriteLine(new string(ans));
    }

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

class Scanner
{
    public Scanner()
    {
        _pos = 0;
        _line = new string[0];
    }

    const char Separator = ' ';
    private int _pos;
    private string[] _line;

    #region スペース区切りで取得

    public string Next()
    {
        if (_pos >= _line.Length)
        {
            _line = Console.ReadLine().Split(Separator);
            _pos = 0;
        }

        return _line[_pos++];
    }

    public int NextInt()
    {
        return int.Parse(Next());
    }

    public long NextLong()
    {
        return long.Parse(Next());
    }

    public double NextDouble()
    {
        return double.Parse(Next());
    }

    #endregion

    #region 型変換

    private int[] ToIntArray(string[] array)
    {
        var result = new int[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            result[i] = int.Parse(array[i]);
        }

        return result;
    }

    private long[] ToLongArray(string[] array)
    {
        var result = new long[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            result[i] = long.Parse(array[i]);
        }

        return result;
    }

    private double[] ToDoubleArray(string[] array)
    {
        var result = new double[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            result[i] = double.Parse(array[i]);
        }

        return result;
    }

    #endregion

    #region 配列取得

    public string[] Array()
    {
        if (_pos >= _line.Length)
            _line = Console.ReadLine().Split(Separator);

        _pos = _line.Length;
        return _line;
    }

    public int[] IntArray()
    {
        return ToIntArray(Array());
    }

    public long[] LongArray()
    {
        return ToLongArray(Array());
    }

    public double[] DoubleArray()
    {
        return ToDoubleArray(Array());
    }

    #endregion
}