Комбинаторика. Вывести все слова, которые можно составить из данных букв

# include <iostream>
# include <fstream>
# include <unordered_map>
# include <algorithm>
# include <string>
 
bool can_create(const std::string &key,std::string string);
int main()
    {
    std::string line;
    std::unordered_map<size_t,std::unordered_map<std::string,size_t>> Dict;
    std::ifstream myfile("_AllWords.txt");
    std::ofstream out("QW2.txt");
    if(myfile.is_open())
        {
        while (std::getline(myfile,line))
            {
            std::sort(line.begin(),line.end());
            Dict[line.size()][line]++;
            }
        myfile.close();
        }
    else 
        std::cout << "Couldn't open file!" << std::endl;
    myfile.open("i1.txt");
 
    if(myfile)
        {
        while (true)
            {
            size_t N,M;
            std::string test;
            myfile>>N;
            myfile>>test;
            if(!myfile) break;
            M = test.size();
            size_t total=0;
            for(const auto &el:Dict[N])
                {
                if(can_create(el.first,test))
                    total+=el.second;
                }
            out<<total<<std::endl;
            }
        myfile.close();
        }
    else 
        std::cout << "Couldn't open file!" << std::endl;
 
    out.close();
    return 0;
    }
 
bool can_create(const std::string &key,std::string string)
    {
    size_t count=0;
    for(const auto &el : key)
        {
        size_t pos = string.find(el);
        if(pos!=std::string::npos)
            {
            string.erase(pos,1);
            count++;
            }
        }
    return count==key.size();
    }

/////////////////////////////////////////////////////////////////////////////////////////
//Подсчитать все слова из заданного словаря, которые можно составить из данных букв, 
//длинна слова соответственно тоже дана.
//
//ВХОДНОЙ ФАЙЛ (где первое число, длина слова, а далее буквы из которых надо составить это слово/слова):
/*
//17
13 p l g l t o i b b a n a n h z t i s f e
9 e s s a s t s i l m e r a k
6 o r l b s k o i d l
8 p o s s b c d a e d d t l
7 l e r i e l o i w a b
10 i e o e i n b f l l x i y u i j
5 h n m m i b d s
10 n o v o i v i z o l n i r r a t
6 b l e v n e k b i s
5 n s h e a r s c
6 l s z a b v h y i y
10 s e d e i t w c u i a m a t a r
5 u q d t b r s s
8 n n e g t l n i s g e x z
11 r b t w e c o m a m i e z d y z u
7 y s t h y o k a e r e
7 e g y z d y v a o u z
*/
//
//ВЫХОДНОЙ ФАЙЛ:
/*
1 4 6 7 6 2 3 2 15 33 2 8 9 11 1 6 1 
*/
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <fstream>
#include <iostream>
#include <iterator>
#include <map>
#include <set>
#include <string>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string                                                                 T_str;
typedef T_str                                                                       T_word;
 
typedef std::multiset   < char                                                  >   T_letters_set;
typedef T_letters_set                                                               T_word_letters_set;
typedef T_letters_set                                                               T_pattern_letters_set;
 
typedef int                                                                         T_word_size;
typedef std::pair       < T_word_size,          T_pattern_letters_set           >   T_pattern;
typedef std::vector     < T_pattern                                             >   T_patterns;
 
typedef std::map        < T_word_letters_set,   int                             >   T_count_of_word_letters_set;
typedef std::map        < T_word_size,          T_count_of_word_letters_set     >   T_dictionary;
/////////////////////////////////////////////////////////////////////////////////////////
T_letters_set    get_letters_set_of_word( T_word  const   &   word )
{
    T_letters_set    res_letset;
 
    std::copy
        (
            word.begin  (),
            word.end    (),
 
            std::inserter
                (
                    res_letset,
                    res_letset.begin()
                )
        );
 
    return  res_letset;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    successfully_from_file_with_name_input_dictionary
    (
        T_str           const   &   dictionary_filename,
        T_dictionary            &   dictionary
    )
{
    std::ifstream   ifile( dictionary_filename );
 
    bool    bool_res    =   ifile   !=  nullptr;
 
    if( bool_res )
    {
        T_word  word_cur;
 
        while( ifile >> word_cur )
        {
            ++dictionary
                [
                    word_cur.size()
                ]
                [
                    get_letters_set_of_word( word_cur )
                ];
        }
    }//if
 
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    successfully_from_file_with_name_input_patterns
    (
        T_str       const   &   patterns_filename,
        T_patterns          &   patterns
    )
{
    std::ifstream   ifile( patterns_filename );
 
    bool    bool_res    =   ifile   !=  nullptr;
 
    if( bool_res )
    {
        int     patterns_count  =   0;
        ifile   >>  patterns_count;
 
        for( int  i = 0; i < patterns_count; ++i )
        {
            int     word_size   =   0;
            T_word  pattern_word;
 
            ifile   >>  word_size;
 
            std::getline
                (
                    ifile,
                    pattern_word
                );
 
            patterns.push_back
                (
                    T_pattern
                        (
                            word_size,
                            get_letters_set_of_word( pattern_word )
                        )
                );
        }//for
    }//if
 
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_count_words_for_pattern_in
{
    //-----------------------------------------------------------------------------------
    const   T_dictionary  &   dictionary_;
    //-----------------------------------------------------------------------------------
    T_count_words_for_pattern_in( T_dictionary    const   &   dictionary )
        :
        dictionary_ ( dictionary )
    {}
    //-----------------------------------------------------------------------------------
    int     operator()  ( T_pattern     const   &   pattern )
    {
        int     word_counter                                =   0;
        auto    word_size_and_count_of_word_letters_set_it  =   dictionary_.find( pattern.first );
 
        if  (
                word_size_and_count_of_word_letters_set_it  !=  dictionary_.end()
            )
        {
            auto    &   count_of_word_letters_set   =   word_size_and_count_of_word_letters_set_it->second;
 
            for (
                    auto
                    word_letters_set_and_count_it   =   count_of_word_letters_set.begin     ();
                    word_letters_set_and_count_it   !=  count_of_word_letters_set.end       ();
                    ++word_letters_set_and_count_it
                )
            {
                if  (
                        std::includes
                            (
                                pattern.second                          .begin  (),
                                pattern.second                          .end    (),
 
                                word_letters_set_and_count_it->first    .begin  (),
                                word_letters_set_and_count_it->first    .end    ()
                            )
                    )
                {
                    word_counter    +=  word_letters_set_and_count_it->second;
                }//if
            }//for
        }//if
 
        return  word_counter;
    }
    //-----------------------------------------------------------------------------------   
};
/////////////////////////////////////////////////////////////////////////////////////////
void    count_words_in_dictionary_for_patterns_and_output_in_file_with_name
    (
        T_dictionary    const   &   dictionary,
        T_patterns      const   &   patterns,
        T_str           const   &   word_counts_filename
    )
{
    std::ofstream   ofile( word_counts_filename );
 
    std::transform
        (
            patterns.begin                  (),
            patterns.end                    (),
            std::ostream_iterator<int>      ( ofile, " "    ),
            T_count_words_for_pattern_in    ( dictionary    )
        );
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    const   T_str   DICTIONARY_FILENAME     =   "all_words.txt";
    const   T_str   PATTERNS_FILENAME       =   "input.txt";
    const   T_str   WORD_COUNTS_FILENAME    =   "output.txt";//
 
    T_dictionary    dictionary;
    T_patterns      patterns;
 
    if  (
                successfully_from_file_with_name_input_dictionary
                    (
                        DICTIONARY_FILENAME,
                        dictionary
                    )
 
            &&  successfully_from_file_with_name_input_patterns
                    (
                        PATTERNS_FILENAME,
                        patterns
                    )
        )
    {
        std::cout   <<  "Данные загружены."
                    <<  std::endl;
 
        count_words_in_dictionary_for_patterns_and_output_in_file_with_name
            (
                dictionary,
                patterns,
                WORD_COUNTS_FILENAME
            );
 
        std::cout   <<  "Слова подсчитаны."
                    <<  std::endl;
    }
    else
    {
        std::cout   <<  "Невозможно прочитать данные из входных файлов."
                    <<  std::endl;
    }
 
    system("pause");
}