Алгоритм Брона-Кербоша или поиск клик в графе

/////////////////////////////////////////////////////////////////////////////////////////
//имеется матрица весов взвешенного ориентированного графа:
//{0, 6, 0, 5, 4},
//{0, 0, 4, 0, 0},
//{0, 0, 0, 3, 6},
//{0, 0, 3, 0, 6},
//{0, 8, 0, 0, 0}
//Следует найти количество путей из вершины V в неё же саму с числом "остановок" в других 
//вершинах не более N (например, вершина 2, кол-во остановок не более 3). 
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iostream>
#include <iterator>
#include <map>
#include <set>
#include <string>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string                                 T_str;
typedef T_str                                       T_vertex;
typedef std::vector     < int                   >   T_row;
typedef std::vector     < T_row                 >   T_matr;
typedef std::multimap   < T_vertex, T_vertex    >   T_vert_from_vert;
typedef std::set        < T_vertex              >   T_vertices;
typedef T_row                                       T_path;
/////////////////////////////////////////////////////////////////////////////////////////
static  const   int     EMPTY_IND  =   -1;
/////////////////////////////////////////////////////////////////////////////////////////
int     index_of_vert
    (
        T_vertex    const   &   v,
        T_vertices  const   &   vertices
    )
{
    return  std::distance
                (
                    vertices.begin  (),
                    vertices.find   ( v )
                );
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    successfully_set_next_neighb_ind_of_after_or_empty
    (
        int                 prev_ind,
        int                 cur_ind,
        T_matr  const   &   matr,
        int             &   res_ind
    )
{
    res_ind     =   EMPTY_IND;
 
    for( size_t  j = cur_ind + 1; j < matr.size(); ++j )
    {
        if  (
                matr[ prev_ind ][ j ]
            )
        {
            res_ind     =   j;
            break;
        }//if
    }//for
 
    return  res_ind     !=  EMPTY_IND;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    successfully_set_first_neighb_ind_of_or_empty
    (
        int                 ind,
        T_matr  const   &   matr,
        int             &   res_ind
    )
{
    return  successfully_set_next_neighb_ind_of_after_or_empty
                (
                    ind,
                    -1,
                    matr,
                    res_ind
                );
}
/////////////////////////////////////////////////////////////////////////////////////////
T_vertex    vert_of_ind
    (
        int                     ind,
        T_vertices  const   &   vertices
    )
{
    auto    it  =   vertices.begin();
    std::advance( it,   ind );
    return  *it;
}
/////////////////////////////////////////////////////////////////////////////////////////
void    print_path
    (
        T_path      const   &   path,
        T_vertices  const   &   vertices
    )
{
    for( size_t  i = 0; i < path.size(); ++i )
    {
        if  (
                path[i]     ==  EMPTY_IND
            )
        {
            break;
        }
 
        std::cout   <<  vert_of_ind
                            (
                                path[i],
                                vertices
                            )
 
                    <<  '\t';
    }//for
 
    std::cout   <<  std::endl;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     count_cycles_from_vert_with_max_stopping_count
    (
        int                     ind_start,
        int                     max_stopping_count,
        T_matr      const   &   matr,
        T_vertices  const   &   vertices
    )
{
    int     cycles_count    =   0;
    int     path_size       =   max_stopping_count + 2;
 
    T_path  path    (
                        path_size,
                        EMPTY_IND
                    );
 
    path.front()    =   ind_start;
 
    do
    {
        for( int  i = 1; i <= path_size - 1; ++i )
        {
            if  (
                    path[i]     ==  EMPTY_IND
                )
            {
                if  (
                        !successfully_set_first_neighb_ind_of_or_empty
                            (
                                path[i - 1],
                                matr,
                                path[i]
                            )
                    )
                {
                    break;
                }
            }
            else if (
                            i               ==  path_size - 1
                        ||  path[i + 1]     ==  EMPTY_IND
                    )
            {
                if  (
                        !successfully_set_next_neighb_ind_of_after_or_empty
                            (
                                path[i - 1],
                                path[i],
                                matr,
                                path[i]
                            )
                    )
                {
                    break;
                }
            }//else
 
            if  (
                    path[i]     ==  ind_start
                )
            {
                ++cycles_count;
 
                print_path
                    (
                        path,
                        vertices
                    );
 
                std::fill
                    (
                        path.begin  ()  +   i + 1,
                        path.end    (),
                        EMPTY_IND
                    );
 
                break;
            }//if
        }//for
    }
    while   (
                path[1]     !=  EMPTY_IND
            );
 
    return  cycles_count;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    std::cout   <<  "Введите количество ребер ориентированного графа: ";
    int     n   =   0;
    std::cin    >>  n;
 
    std::cout   <<  "Введите "
                <<  n
                <<  " ребер ориентированного графа:"
                <<  std::endl;
 
    T_vert_from_vert    vert_from_vert;
    T_vertices          vertices;
 
    for( int  i = 0; i < n; ++i )
    {
        std::cout   <<  std::endl
                    <<  '#'
                    <<  i + 1
                    <<  std::endl;
 
        std::cout   <<  "\tv1\t= ";
        T_vertex    v1;
        std::cin    >>  v1;
 
        std::cout   <<  "\tv2\t= ";
        T_vertex    v2;
        std::cin    >>  v2;
 
        vertices.insert(v1);
        vertices.insert(v2);
 
        vert_from_vert.insert
            (
                std::make_pair( v1, v2 )
            );
    }//for
 
    int     vertices_count  =   vertices.size();
 
    T_matr  matr    (
                        vertices_count,
                        T_row( vertices_count )
                    );
 
    std::for_each
        (
            vert_from_vert.begin    (),
            vert_from_vert.end      (),
 
            [&] ( T_vert_from_vert::value_type  const   &   v1_v2 )
            {
                    matr    [ index_of_vert( v1_v2.first,   vertices    ) ]
                            [ index_of_vert( v1_v2.second,  vertices    ) ]
                =   1;
            }
        );
 
    for(;;)
    {
        T_vertex    v_start;
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl;
        do
        {
            std::cout   <<  "Введите обозначение стартовой вершины\t\t\t: ";
            std::cin    >>  v_start;
        }
        while   (
                    vertices.count( v_start )   ==  0
                );
        
        std::cout   <<  "Введите максимальное количество остановок в циклах\t: ";
        int     max_stopping_count   =   0;
        std::cin    >>  max_stopping_count;
 
        std::cout   <<  std::endl
                    <<  "В графе имеется "
 
                    <<  count_cycles_from_vert_with_max_stopping_count
                            (
                                index_of_vert( v_start,     vertices ),
                                max_stopping_count,
                                matr,
                                vertices
                            )
 
                    <<  " циклов из вершины "
                    <<  v_start
                    <<  " с числом остановок не более "
                    <<  max_stopping_count
                    <<  "."
                    <<  std::endl;
    }//for
}