Задачи на конечные автоматы

#include <iostream>
#include <cstdlib>
#include <string>
#include <locale>
#include <map>
#include <utility>
 
 
int main()
{
    std::locale::global(std::locale(""));
 
    std::map<std::pair<int, char>, int> D; // таблица переходов
 
    D[std::make_pair(0, '+')] = 1;
    D[std::make_pair(0, '-')] = 1;
    D[std::make_pair(0, '.')] = 2;
    D[std::make_pair(1, '.')] = 2;
    D[std::make_pair(3, 'e')] = 4;
    D[std::make_pair(3, 'E')] = 4;
    D[std::make_pair(4, '+')] = 5;
    D[std::make_pair(4, '-')] = 5;
 
    for (char ch = '0'; ch <= '9'; ++ch)
    {
        D[std::make_pair(0, ch)] = 1;
        D[std::make_pair(1, ch)] = 1;
        D[std::make_pair(2, ch)] = 3;
        D[std::make_pair(3, ch)] = 3;
        D[std::make_pair(4, ch)] = 6;
        D[std::make_pair(5, ch)] = 6;
        D[std::make_pair(6, ch)] = 6;
    }
 
    std::string s;
    std::cin >> s;
 
    int state = 0; // состояние
    std::string::iterator it;
 
    for (it = s.begin(); it != s.end(); ++it) // входные символы
    {
        std::map<std::pair<int, char>, int>::iterator ns_it = D.find(std::make_pair(state, *it));
        if (ns_it == D.end()) break; // нет перехода
        state = ns_it->second; // следующее состояние
    }
 
    // 3 и 6 - допускающие состояния
    if ((state == 3 || state == 6) && it == s.end()) std::cout << "Yes.\n";
    else std::cout << "No.\n";
 
    system("pause");
    return 0;
}

/////////////////////////////////////////////////////////////////////////////////////////
//Построить автомат, распознающий регулярные выражения вида: (101)*(110)*
/////////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <utility>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
/////////////////////////////////////////////////////////////////////////////////////////
class   T_FSM_base  //Базовый класс для любого конечного автомата. В классе-наследнике
                    //достаточно определить значения состояний, заполнить таблицу переходов
                    //и множество допускающих состояний.
{
    //-----------------------------------------------------------------------------------
    typedef int                                                 T_state;
    typedef std::pair   < T_state,              char        >   T_state_and_symb;
    typedef std::map    < T_state_and_symb,     T_state     >   T_state_transition_table;
    typedef std::set    < T_state                           >   T_states;
    //-----------------------------------------------------------------------------------
    T_state                     cur_state_;
    T_state_transition_table    state_transition_table_;
    T_states                    final_states_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_FSM_base( T_state     start_state )
        :
        cur_state_( start_state )
    {}
    //-----------------------------------------------------------------------------------
    bool    string_is_accepted( T_str   &   s )
    {
        for( auto  c_it = s.begin(); c_it != s.end(); ++c_it )
        {
            if  (
                    !successfully_set_cur_state_for_symb( *c_it )
                )
            {
                return  false;
            }
        }//for
 
        return  cur_state_is_final();
    }
    //-----------------------------------------------------------------------------------
    void    add_rule
        (
            T_state     cur_state,
            char        symb,
            T_state     new_state
        )
    {
        state_transition_table_
            [    
                T_state_and_symb
                    (
                        cur_state,
                        symb
                    )
            ]
        
            =   new_state;
    }
    //-----------------------------------------------------------------------------------
    void    add_final_state( T_state    state )
    {
        final_states_.insert( state );
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    bool    successfully_set_cur_state_for_symb( char   symb )
    {
        auto    tr_it   =   state_transition_table_.find
                                (
                                    T_state_and_symb
                                        (
                                            cur_state_,
                                            symb
                                        )
                                );
 
        bool    bool_res    =   tr_it   !=  state_transition_table_.end();
 
        if( bool_res )
        {
            cur_state_  =   tr_it->second;
        }
 
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool    cur_state_is_final()
    {
        return  final_states_.count( cur_state_ )   !=  0;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
class   T_FSM_101_110   :   public  T_FSM_base
{
    //-----------------------------------------------------------------------------------
    enum    T_state_val
    {
        start,
        _1,
        _10,
        _11
    };
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_FSM_101_110()
        :
        T_FSM_base( start )
    {
        add_rule(   start,  '1',    _1      );
        add_rule(   _1,     '0',    _10     );
        add_rule(   _1,     '1',    _11     );
        add_rule(   _10,    '1',    start   );
        add_rule(   _11,    '0',    start   );
 
        add_final_state( start );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
 
    for(;;)
    {
        std::cout   <<  "Проверка регулярного выражения (101)*(110)*"
                    <<  std::endl;
 
        std::cout   <<  "Введите строку символов:"
                    <<  std::endl;
 
        T_str   s;
        getline( std::cin, s );
 
        T_FSM_101_110   fsm;
 
        std::cout   <<  std::endl
                    <<  (
                            fsm.string_is_accepted(s)
                                ?   "Строка допускается"
                                :   "Строка НЕ допускается"
                        )
 
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl;
    }
}