Определить порядок получения подписей минимизирующий сумму уплаченных взяток

///////////////////////////////////////////////////////////////////////////////
//2.
///////////////////////////////////////////////////////////////////////////////
//Есть министерство из N чиновников, где N натуральное число.
//У каждого из чиновников могут быть как подчиненные, так и начальники,
//причем справедливы правила: подчиненные моего подчиненного мои подчиненные,
//начальники моего начальника - мои начальники, мой начальник не есть мой
//подчиненный, у каждого чиновника не более одного непосредственного начальника.
//Для того чтобы получить лицензию на вывоз меди необходимо получить подпись
//1-ого чиновника - начальника всех чиновников. Проблема осложняется тем,
//что каждый чиновник, вообще говоря, может потребовать "визы", т.е. подписи
//некоторых своих непосредственных подчиненных и взятку - известное количество
//долларов. Для каждого чиновника известен непустой список возможных наборов
//"виз" и соответствующая каждому набору взятка. Пустой набор означает, что
//данный чиновник не требует виз в данном случае. Чиновник ставит свою подпись
//лишь после того, как ему представлены все подписи одного из наборов "виз"
//и уплачена соответствующая взятка.
//Необходимо определить и вывести минимальный по сумме уплаченных взяток
//допустимый порядок получения подписей для лицензии и стоимость.
//N<100. Количество наборов для каждого чиновника не превосходит 15.
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iostream>
#include <set>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
class   T_official;
///////////////////////////////////////////////////////////////////////////////
typedef T_official  *                       T_off_tree;
typedef std::vector     < T_off_tree    >   T_off_trees;
typedef int                                 T_id;
typedef std::set        < T_id          >   T_ids;
///////////////////////////////////////////////////////////////////////////////
struct  T_resolution
{
    //---------------------------------------------------------------------
    int     price_;
    T_ids   actors_ids_;
    int     full_price_     =   {};
    //---------------------------------------------------------------------
    T_resolution
        (
            int                 price,
            T_ids   const   &   actors_ids
        )
        :
        price_          ( price         ),
        actors_ids_     ( actors_ids    )
    {}
    //---------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
typedef std::vector     < T_resolution  >   T_resolutions;
///////////////////////////////////////////////////////////////////////////////
class   T_official
{
    //-------------------------------------------------------------------------
    int                         id_;
    T_resolutions               resolutions_;
 
    T_off_trees                 sub_trees_;
    T_resolutions::iterator     res_min_it_             =   resolutions_.end();
    int                         price_min_              =   {};
    bool                        price_min_is_valid_     =   {};
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    T_official
        (
            int                         id,
            T_resolutions   const   &   resolutions
        )
        :
        id_             ( id ),
        resolutions_    ( resolutions )
    {}
    //-------------------------------------------------------------------------
    void    print_price_min_and_id_of_actors_of_price_min()
    {
        std::cout   <<  get_price_min()
                    <<  std::endl;
 
        print_id_and_id_of_price_min_actors();
        std::cout   <<  std::endl;
    }
    //-------------------------------------------------------------------------
    void    add_sub( T_off_tree     const   &   off_tree )
    {
        sub_trees_.emplace_back( off_tree );
    }
    //-------------------------------------------------------------------------
private:
    //-------------------------------------------------------------------------
    int     get_price_min()
    {
        set_price_min_if_not_valid();
        return  price_min_;
    }
    //-------------------------------------------------------------------------
    void    set_price_min_if_not_valid()
    {
        if  (
                price_min_is_valid_
            )
        {
            return;
        }
 
        price_min_is_valid_     =   true;
 
        for( auto   &   res     :   resolutions_ )
        {
            set_res_full_price( res );
        }
 
        set_res_min_it();
        price_min_  =   res_min_it_->full_price_;
    }
    //-------------------------------------------------------------------------
    void    set_res_full_price( T_resolution    &   res )
    {
        res.full_price_     =   res.price_;
 
        for( auto   actor_id    :   res.actors_ids_ )
        {
            auto    const   &   sub_tree_it     =   get_sub_tree_it( actor_id );
 
            if  (
                    sub_tree_it     !=  sub_trees_.end()
                )
            {
                res.full_price_     +=  ( *sub_tree_it )->get_price_min();
            }
        }//for
    }
    //-------------------------------------------------------------------------
    void    set_res_min_it()
    {
        res_min_it_     =   std::min_element
                                (
                                    resolutions_.begin  (),
                                    resolutions_.end    (),
 
                                    []                  (
                                                            auto    const   &   L_res,
                                                            auto    const   &   R_res
                                                        )
                                    {
                                        return      L_res.full_price_
                                                <   R_res.full_price_;
                                    }
                                );
    }
    //-------------------------------------------------------------------------
    void    print_id_and_id_of_price_min_actors()                           const
    {
        std::cout   <<  id_
                    <<  '\t';
 
        if  (
                    res_min_it_
                ==  resolutions_.end()
            )
        {
            return;
        }
 
        for( auto   actor_id    :   res_min_it_->actors_ids_ )
        {
            auto    const   &   sub_tree_it     =   get_sub_tree_it( actor_id );
 
            if  (
                    sub_tree_it     !=  sub_trees_.end()
                )
            {
                ( *sub_tree_it )->print_id_and_id_of_price_min_actors();
            }
        }//for
    }
    //-------------------------------------------------------------------------
    T_off_trees::const_iterator   get_sub_tree_it( T_id   id )              const
    {
        return  std::find_if
                    (
                        sub_trees_.begin    (),
                        sub_trees_.end      (),
 
                        [=]                 (
                                                auto    const   &   sub_tree
                                            )
                        {
                            return  sub_tree->id_   ==  id;
                        }
                    );
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    T_off_tree  off_tree_1  =   new     T_official
                                            (
                                                1,
                                                {
                                                    { 10,   {2, 3}  },
                                                    { 20,   {3, 4}  }
                                                }
                                            );
 
    T_off_tree  off_tree_2  =   new     T_official
                                            (
                                                2,
                                                {
                                                    { 30,   {}  }
                                                }
                                            );
 
 
    T_off_tree  off_tree_3  =   new     T_official
                                            (
                                                3,
                                                {
                                                    { 40,   {5}     },
                                                    { 50,   {5, 6}  }
                                                }
                                            );
 
    T_off_tree  off_tree_4  =   new     T_official
                                            (
                                                4,
                                                {
                                                    { 50,   {}  }
                                                }
                                            );
 
    T_off_tree  off_tree_5  =   new     T_official
                                            (
                                                5,
                                                {
                                                    { 60,   {}  }
                                                }
                                            );
 
    T_off_tree  off_tree_6  =   new     T_official
                                            (
                                                6,
                                                {
                                                    { 70,   {}  }
                                                }
                                            );
 
    off_tree_3->add_sub( off_tree_5 );
    off_tree_3->add_sub( off_tree_6 );
 
    off_tree_1->add_sub( off_tree_2 );
    off_tree_1->add_sub( off_tree_3 );
    off_tree_1->add_sub( off_tree_4 );
 
    off_tree_1->print_price_min_and_id_of_actors_of_price_min();
}